home *** CD-ROM | disk | FTP | other *** search
/ .net 2002 March / DotNetMagazine-Issue107-Coverdisc-NET107-02-03-PCMac.bin / pc / PC Software / picks / HTTrack / httrack-3.22-3.exe / {app} / src / htslib.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-11-17  |  116.6 KB  |  4,348 lines
  1. /* ------------------------------------------------------------ */
  2. /*
  3. HTTrack Website Copier, Offline Browser for Windows and Unix
  4. Copyright (C) Xavier Roche and other contributors
  5.  
  6. This program is free software; you can redistribute it and/or
  7. modify it under the terms of the GNU General Public License
  8. as published by the Free Software Foundation; either version 2
  9. of the License, or any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  
  20.  
  21. Important notes:
  22.  
  23. - We hereby ask people using this source NOT to use it in purpose of grabbing
  24. emails addresses, or collecting any other private information on persons.
  25. This would disgrace our work, and spoil the many hours we spent on it.
  26.  
  27.  
  28. Please visit our Website: http://www.httrack.com
  29. */
  30.  
  31.  
  32. /* ------------------------------------------------------------ */
  33. /* File: Subroutines                                            */
  34. /* Author: Xavier Roche                                         */
  35. /* ------------------------------------------------------------ */
  36.  
  37. // Fichier librairie .c
  38.  
  39. #include "htslib.h"
  40. #include "htsbauth.h"
  41.  
  42. /* specific definitions */
  43. #include "htsbase.h"
  44. #include "htsnet.h"
  45. #include "htsbauth.h"
  46. #include "htsthread.h"
  47. #include "htsnostatic.h"
  48. #include "htswrap.h"
  49. #include <stdio.h>
  50. #if HTS_WIN
  51. #include <direct.h>
  52. #else
  53. #if HAVE_UNISTD_H
  54. #include <unistd.h>
  55. #endif
  56. #endif
  57. #include <stdlib.h>
  58. #include <string.h>
  59. #include <time.h>
  60. #include <sys/timeb.h>
  61. #include <fcntl.h>
  62. // pour utimbuf
  63. #if HTS_WIN
  64. #include <sys/utime.h>
  65. #else
  66. #include <utime.h>
  67. #endif
  68. /* END specific definitions */
  69.  
  70.  
  71.  
  72. // DÈbuggage de contrÙle
  73. #if HTS_DEBUG_CLOSESOCK
  74. #define _HTS_WIDE 1
  75. #endif
  76. #if HTS_WIDE_DEBUG
  77. #define _HTS_WIDE 1
  78. #endif
  79. #if _HTS_WIDE
  80. FILE* DEBUG_fp=NULL;
  81. #define DEBUG_W(A)  { if (DEBUG_fp==NULL) DEBUG_fp=fopen("bug.out","wb"); fprintf(DEBUG_fp,":>"A); fflush(DEBUG_fp); }
  82. #define DEBUG_W2(A) { if (DEBUG_fp==NULL) DEBUG_fp=fopen("bug.out","wb"); fprintf(DEBUG_fp,A); fflush(DEBUG_fp); }
  83. #endif
  84.  
  85. /* variables globales */
  86. int _DEBUG_HEAD;
  87. FILE* ioinfo;
  88.  
  89. #if HTS_USEOPENSSL
  90.  SSL_CTX *openssl_ctx = NULL;
  91. #endif
  92. int IPV6_resolver = 0;
  93.  
  94.  
  95. /* dÈtection complÈmentaire */
  96. const char hts_detect[][32] = {
  97.   "archive",
  98.   "background",
  99.   "data",         // OBJECT
  100.   "dynsrc",
  101.   "lowsrc",
  102.   "profile",      // element META
  103.   "src",
  104.   "swurl",
  105.   "url",
  106.   "usemap",
  107.   "longdesc",     // accessibility
  108.   "xlink:href",   // xml/svg tag
  109.   ""
  110. };
  111.  
  112. /* dÈtecter dÈbut */
  113. const char hts_detectbeg[][32] = {
  114.   "hotspot",      /* hotspot1=..,hotspot2=.. */
  115.   ""
  116. };
  117.  
  118. /* ne pas dÈtcter de liens dedans */
  119. const char hts_nodetect[][32] = {
  120.   "accept-charset",
  121.   "accesskey",
  122.   "action",
  123.   "align",
  124.   "alt",
  125.   "axes",
  126.   "axis",
  127.   "char",
  128.   "charset",
  129.   "cite",
  130.   "class",
  131.   "classid",
  132.   "code",
  133.   "color",
  134.   "datetime",
  135.   "dir",
  136.   "enctype",
  137.   "face",
  138.   "height",
  139.   "id",
  140.   "lang",
  141.   "language",
  142.   "media",
  143.   "method",
  144.   "name",
  145.   "prompt",
  146.   "scheme",
  147.   "size",
  148.   "style",
  149.   "target",
  150.   "title",
  151.   "type",
  152.   "valign",
  153.   "version",
  154.   "width",
  155.   ""
  156. };
  157.  
  158.  
  159. /* dÈtection de mini-code javascript */
  160. /* ALSO USED: detection based on the name: onXXX="<tag>" where XXX starts with upper case letter */
  161. const char hts_detect_js[][32] = {
  162.   "onAbort",
  163.   "onBlur",
  164.   "onChange",
  165.   "onClick",
  166.   "onDblClick",
  167.   "onDragDrop",
  168.   "onError",
  169.   "onFocus",
  170.   "onKeyDown",
  171.   "onKeyPress",
  172.   "onKeyUp",
  173.   "onLoad",
  174.   "onMouseDown",
  175.   "onMouseMove",
  176.   "onMouseOut",
  177.   "onMouseOver",
  178.   "onMouseUp",
  179.   "onMove",
  180.   "onReset",
  181.   "onResize",
  182.   "onSelect",
  183.   "onSubmit",
  184.   "onUnload",
  185.   ""
  186. };
  187.  
  188. /* dÈtection "...URL=<url>" */
  189. const char hts_detectURL[][32] = {
  190.   "content",
  191.   ""
  192. };
  193.  
  194. /* tags o˘ l'URL doit Ítre rÈÈcrite mais non capturÈe */
  195. const char hts_detectandleave[][32] = {
  196.   "action",
  197.   ""
  198. };
  199.  
  200. /* ne pas renommer les types renvoyÈs (souvent types inconnus) */
  201. const char hts_mime_keep[][32] = {
  202.   "application/octet-stream",
  203.   "text/plain",
  204.   ""
  205. };
  206.  
  207. /* pas de type mime connu, mais extension connue */
  208. const char hts_ext_dynamic[][32] = {
  209.   "php3",
  210.   "php",
  211.   "php4",
  212.   "php2",
  213.   "cgi",
  214.   "asp",
  215.   "jsp",
  216.   "pl",
  217.   /*"exe",*/
  218.   "cfm",
  219.   ""
  220. };
  221.  
  222. /* types MIME */
  223. const char hts_mime[][2][32] = {
  224.   {"application/acad","dwg"},
  225.   {"application/arj","arj"},
  226.   {"application/clariscad","ccad"},
  227.   {"application/drafting","drw"},
  228.   {"application/dxf","dxf"},
  229.   {"application/excel","xls"},
  230.   {"application/i-deas","unv"},
  231.   {"application/iges","isg"},
  232.   {"application/iges","iges"},
  233.   {"application/mac-binhex40","hqx"},
  234.   {"application/mac-compactpro","cpt"},
  235.   {"application/msword","doc"},
  236.   {"application/msword","w6w"},
  237.   {"application/msword","word"},
  238.   {"application/mswrite","wri"},
  239.   /*{"application/octet-stream","dms"},*/
  240.   /*{"application/octet-stream","lzh"},*/
  241.   /*{"application/octet-stream","lha"},*/
  242.   /*{"application/octet-stream","bin"},*/
  243.   {"application/oda","oda"},
  244.   {"application/pdf","pdf"},
  245.   {"application/postscript","ps"},
  246.   {"application/postscript","ai"},
  247.   {"application/postscript","eps"},
  248.   {"application/powerpoint","ppt"},
  249.   {"application/pro_eng","prt"},
  250.   {"application/pro_eng","part"},
  251.   {"application/rtf","rtf"},
  252.   {"application/set","set"},
  253.   {"application/sla","stl"},
  254.   {"application/smil","smi"},
  255.   {"application/smil","smil"},
  256.   {"application/smil","sml"},
  257.   {"application/solids","sol"},
  258.   {"application/STEP","stp"},
  259.   {"application/STEP","step"},
  260.   {"application/vda","vda"},
  261.   {"application/x-authorware-map","aam"},     
  262.   {"application/x-authorware-seg","aas"},
  263.   {"application/x-authorware-bin","aab"},
  264.   {"application/x-cocoa","cco"},
  265.   {"application/x-csh","csh"},
  266.   {"application/x-director","dir"},
  267.   {"application/x-director","dcr"},
  268.   {"application/x-director","dxr"},
  269.   {"application/x-mif","mif"},
  270.   {"application/x-dvi","dvi"},
  271.   {"application/x-gzip","gz"},
  272.   {"application/x-gzip","gzip"},
  273.   {"application/x-hdf","hdf"},
  274.   {"application/x-javascript","js"},
  275.   {"application/x-koan","skp"},
  276.   {"application/x-koan","skd"},
  277.   {"application/x-koan","skt"},
  278.   {"application/x-koan","skm"},
  279.   {"application/x-latex","latex"},
  280.   {"application/x-netcdf","nc"},
  281.   {"application/x-netcdf","cdf"},
  282.   /* {"application/x-sh","sh"}, */
  283.   /* {"application/x-csh","csh"}, */
  284.   /* {"application/x-ksh","ksh"}, */
  285.   {"application/x-shar","shar"},
  286.   {"application/x-stuffit","sit"},
  287.   {"application/x-tcl","tcl"},
  288.   {"application/x-tex","tex"},
  289.   {"application/x-texinfo","texinfo"},
  290.   {"application/x-texinfo","texi"},
  291.   {"application/x-troff","t"},
  292.   {"application/x-troff","tr"},
  293.   {"application/x-troff","roff"},
  294.   {"application/x-troff-man","man"},
  295.   {"application/x-troff-me","ms"},
  296.   {"application/x-wais-source","src"},
  297.   {"application/zip","zip"},
  298.   {"application/x-zip-compressed","zip"},
  299.   {"application/x-bcpio","bcpio"},
  300.   {"application/x-cdlink","vcd"},
  301.   {"application/x-cpio","cpio"},
  302.   {"application/x-gtar","tgz"},
  303.   {"application/x-gtar","gtar"},
  304.   {"application/x-shar","shar"},
  305.   {"application/x-shockwave-flash","swf"},
  306.   {"application/x-sv4cpio","sv4cpio"},
  307.   {"application/x-sv4crc","sv4crc"},
  308.   {"application/x-tar","tar"},
  309.   {"application/x-ustar","ustar"},
  310.   {"application/x-winhelp","hlp"},
  311.   {"audio/midi","mid"},
  312.   {"audio/midi","midi"},
  313.   {"audio/midi","kar"},
  314.   {"audio/mpeg","mp3"},
  315.   {"audio/mpeg","mpga"},
  316.   {"audio/mpeg","mp2"},
  317.   {"audio/basic","au"},
  318.   {"audio/basic","snd"},
  319.   {"audio/x-aiff","aif"},
  320.   {"audio/x-aiff","aiff"},
  321.   {"audio/x-aiff","aifc"},
  322.   {"audio/x-pn-realaudio","rm"},
  323.   {"audio/x-pn-realaudio","ram"},
  324.   {"audio/x-pn-realaudio","ra"},
  325.   {"audio/x-pn-realaudio-plugin","rpm"},
  326.   {"audio/x-wav","wav"},
  327.   {"chemical/x-pdb","pdb"},
  328.   {"chemical/x-pdb","xyz"},
  329.   {"drawing/x-dwf","dwf"},
  330.   {"image/gif","gif"},
  331.   {"image/ief","ief"},
  332.   {"image/jpeg","jpg"},
  333.   {"image/jpeg","jpe"},
  334.   {"image/jpeg","jpeg"},
  335.   {"image/pict","pict"},
  336.   {"image/png","png"},
  337.   {"image/tiff","tiff"},
  338.   {"image/tiff","tif"},
  339.   {"image/svg+xml","svg"},
  340.   {"image/svg-xml","svg"},
  341.   {"image/x-cmu-raster","ras"},
  342.   {"image/x-freehand","fh4"},
  343.   {"image/x-freehand","fh7"},
  344.   {"image/x-freehand","fh5"},  
  345.   {"image/x-freehand","fhc"},
  346.   {"image/x-freehand","fh"},   
  347.   {"image/x-portable-anymap","pnm"},
  348.   {"image/x-portable-bitmap","pgm"},
  349.   {"image/x-portable-pixmap","ppm"},
  350.   {"image/x-rgb","rgb"},
  351.   {"image/x-xbitmap","xbm"},
  352.   {"image/x-xpixmap","xpm"},
  353.   {"image/x-xwindowdump","xwd"},
  354.   {"model/mesh","msh"},  
  355.   {"model/mesh","mesh"},  
  356.   {"model/mesh","silo"},  
  357.   {"multipart/x-zip","zip"},
  358.   {"multipart/x-gzip","gzip"},
  359.   {"text/css","css"},
  360.   {"text/html","html"},
  361.   {"text/html","htm"},
  362.   {"text/plain","txt"},
  363.   {"text/plain","g"},
  364.   {"text/plain","h"},
  365.   {"text/plain","c"},
  366.   {"text/plain","cc"},
  367.   {"text/plain","hh"},
  368.   {"text/plain","m"},
  369.   {"text/plain","f90"},
  370.   {"text/richtext","rtx"},
  371.   {"text/tab-separated-values","tsv"},
  372.   {"text/x-setext","etx"},
  373.   {"text/x-sgml","sgml"},
  374.   {"text/x-sgml","sgm"},
  375.   {"text/xml","xml"},  
  376.   {"text/xml","dtd"},  
  377.   {"video/mpeg","mpeg"},
  378.   {"video/mpeg","mpg"},
  379.   {"video/mpeg","mpe"},
  380.   {"video/quicktime","qt"},
  381.   {"video/quicktime","mov"},
  382.   {"video/x-msvideo","avi"},
  383.   {"video/x-sgi-movie","movie"},
  384.   {"x-conference/x-cooltalk","ice"},
  385.   /*{"application/x-httpd-cgi","cgi"},*/
  386.   {"x-world/x-vrml","wrl"},
  387.   
  388.   {"*","class"},
  389.   
  390.   {"",""}};
  391.  
  392.  
  393. // Reserved (RFC2396)
  394. #define CHAR_RESERVED(c)  ( strchr(";/?:@&=+$,",(unsigned char)(c)) != 0 )
  395. // Delimiters (RFC2396)
  396. #define CHAR_DELIM(c)     ( strchr("<>#%\"",(unsigned char)(c)) != 0 )
  397. // Unwise (RFC2396)
  398. #define CHAR_UNWISE(c)    ( strchr("{}|\\^[]`",(unsigned char)(c)) != 0 )
  399. // Special (escape chars) (RFC2396 + >127 )
  400. #define CHAR_LOW(c)       ( ((unsigned char)(c) <= 31) )
  401. #define CHAR_HIG(c)       ( ((unsigned char)(c) >= 127) )
  402. #define CHAR_SPECIAL(c)   ( CHAR_LOW(c) || CHAR_HIG(c) )
  403. // We try to avoid them and encode them instead
  404. #define CHAR_XXAVOID(c)   ( strchr(" *'\"!",(unsigned char)(c)) != 0 )
  405.  
  406.  
  407. // conversion Èventuelle / vers antislash
  408. #if HTS_WIN
  409. char* antislash(char* s) {
  410.   char* buff;
  411.   char* a;
  412.   NOSTATIC_RESERVE(buff, char, HTS_URLMAXSIZE*2);
  413.  
  414.   strcpybuff(buff,s);
  415.   while(a=strchr(buff,'/')) *a='\\';
  416.   return buff;
  417. }
  418. #endif
  419.  
  420.  
  421.  
  422. // RÈcupÈration d'un fichier http sur le net.
  423. // Renvoie une adresse sur le bloc de mÈmoire, ou bien
  424. // NULL si un retour.msgeur (buffer retour.msg) est survenue. 
  425. //
  426. // Une adresse de structure htsmsg peut Ítre transmise pour
  427. // suivre l'Èvolution du chargement si le process a ÈtÈ lancÈ 
  428. // en background
  429.  
  430. htsblk httpget(char* url) {
  431.   char adr[HTS_URLMAXSIZE*2];   // adresse
  432.   char fil[HTS_URLMAXSIZE*2];   // chemin
  433.   
  434.   // sÈparer URL en adresse+chemin
  435.   if (ident_url_absolute(url,adr,fil)==-1) {
  436.     htsblk retour;
  437.     memset(&retour, 0, sizeof(htsblk));    // effacer
  438.     // retour prÈdÈfini: erreur
  439.     retour.adr=NULL;
  440.     retour.size=0;
  441.     retour.msg[0]='\0';
  442.     retour.statuscode=-1;    
  443.     strcpybuff(retour.msg,"Error invalid URL");
  444.     return retour;
  445.   }
  446.   
  447.   return xhttpget(adr,fil);
  448. }
  449.  
  450. // ouvre une liaison http, envoie une requËte GET et rÈceptionne le header
  451. // retour: socket
  452. int http_fopen(char* adr,char* fil,htsblk* retour) {
  453.   //                / GET, traiter en-tÍte
  454.   return http_xfopen(0,1,1,NULL,adr,fil,retour);
  455. }
  456.  
  457. // ouverture d'une liaison http, envoi d'une requËte
  458. // mode: 0 GET  1 HEAD  [2 POST]
  459. // treat: traiter header?
  460. // waitconnect: attendre le connect()
  461. // note: dans retour, on met les params du proxy
  462. int http_xfopen(int mode,int treat,int waitconnect,char* xsend,char* adr,char* fil,htsblk* retour) {
  463.   //htsblk retour;
  464.   //int bufl=TAILLE_BUFFER;    // 8Ko de buffer
  465.   T_SOC soc=INVALID_SOCKET;
  466.   //char *p,*q;
  467.   
  468.   // retour prÈdÈfini: erreur
  469.   if (retour) {
  470.     retour->adr=NULL;
  471.     retour->size=0;
  472.     retour->msg[0]='\0';
  473.     retour->statuscode=-5;          // a priori erreur non fatale
  474.   }
  475.  
  476. #if HDEBUG
  477.   printf("adr=%s\nfichier=%s\n",adr,fil);
  478. #endif
  479.   
  480.   // ouvrir liaison
  481. #if HDEBUG
  482.   printf("CrÈation d'une socket sur %s\n",adr);
  483. #endif
  484.  
  485. #if CNXDEBUG
  486.   printf("..newhttp\n");
  487. #endif
  488.  
  489.   /* connexion */
  490.   if (retour) {
  491.     if ( (!(retour->req.proxy.active)) 
  492.       ||
  493.       (
  494.         (strcmp(adr,"file://")==0) 
  495.         ||
  496.         (strncmp(adr,"https://", 8)==0) 
  497.       )
  498.       ) {    /* pas de proxy, ou non utilisable ici */
  499.       soc=newhttp(adr,retour,-1,waitconnect);
  500.     } else {
  501.       soc=newhttp(retour->req.proxy.name,retour,retour->req.proxy.port,waitconnect);  // ouvrir sur le proxy ‡ la place
  502.     }
  503.   } else {
  504.     soc=newhttp(adr,NULL,-1,waitconnect);    
  505.   }
  506.  
  507.   // copier index socket retour
  508.   if (retour) retour->soc=soc;
  509.  
  510.   /* Check for errors */
  511.   if (soc == INVALID_SOCKET) {
  512.     if (retour) {
  513.       if (retour->msg) {
  514.         if (!strnotempty(retour->msg)) {
  515.           strcpybuff(retour->msg,"Connect error");
  516.         }
  517.       }
  518.     }
  519.   }
  520.  
  521.   // --------------------
  522.   // court-circuit (court circuite aussi le proxy..)
  523.   // LOCAL_SOCKET_ID est une pseudo-socket locale
  524.   if (soc==LOCAL_SOCKET_ID) {
  525.     retour->is_file=1;  // fichier local
  526.     if (mode==0) {    // GET
  527.  
  528.       // Test en cas de file:///C|...
  529.       if (!fexist(fconv(unescape_http(fil))))
  530.         if (fexist(fconv(unescape_http(fil+1)))) {
  531.           char tempo[HTS_URLMAXSIZE*2];
  532.           strcpybuff(tempo,fil+1);
  533.           strcpybuff(fil,tempo);
  534.         }
  535.  
  536.       // Ouvrir
  537.       retour->totalsize=fsize(fconv(unescape_http(fil)));  // taille du fichier
  538.       retour->msg[0]='\0';
  539.       soc=INVALID_SOCKET;
  540.       if (retour->totalsize<0)
  541.         strcpybuff(retour->msg,"Unable to open file");
  542.       else if (retour->totalsize==0)
  543.         strcpybuff(retour->msg,"File empty");
  544.       else {
  545.         // Note: On passe par un FILE* (plus propre)
  546.         //soc=open(fil,O_RDONLY,0);    // en lecture seule!
  547.         retour->fp=fopen(fconv(unescape_http(fil)),"rb");  // ouvrir
  548.         if (retour->fp==NULL)
  549.           soc=INVALID_SOCKET;
  550.         else
  551.           soc=LOCAL_SOCKET_ID;
  552.       }
  553.       retour->soc=soc;
  554.       if (soc!=INVALID_SOCKET) {
  555.         retour->statuscode=200;   // OK
  556.         strcpybuff(retour->msg,"OK");
  557.         guess_httptype(retour->contenttype,fil);
  558.       } else if (strnotempty(retour->msg)==0)
  559.           strcpybuff(retour->msg,"Unable to open file");
  560.       return soc;  // renvoyer
  561.     } else {    // HEAD ou POST : interdit sur un local!!!! (c'est idiot!)
  562.       strcpybuff(retour->msg,"Unexpected Head/Post local request");
  563.       soc=INVALID_SOCKET;    // erreur
  564.       retour->soc=soc;
  565.       return soc;
  566.     }
  567.   } 
  568.   // --------------------
  569.  
  570.   if (soc!=INVALID_SOCKET) {    
  571.     char rcvd[1100];
  572.     rcvd[0]='\0';
  573. #if HDEBUG
  574.     printf("Ok, connexion rÈussie, id=%d\n",soc);
  575. #endif
  576.     
  577.     // connectÈ?
  578.     if (waitconnect) {
  579.       http_sendhead(NULL,mode,xsend,adr,fil,NULL,NULL,retour);
  580.     } 
  581.     
  582.     if (soc!=INVALID_SOCKET) {
  583.       
  584. #if HDEBUG
  585.       printf("Attente de la rÈponse:\n");
  586. #endif
  587.       
  588.       // si GET (rÈception d'un fichier), rÈceptionner en-tÍte d'abord,
  589.       // et ensuite le corps
  590.       // si POST on ne rÈceptionne rien du tout, c'est aprËs que l'on fera
  591.       // une rÈception standard pour rÈcupÈrer l'en tÍte
  592.       if ((treat) && (waitconnect)) {  // traiter (attendre!) en-tÍte        
  593.         // RÈception de la status line et de l'en-tÍte (norme RFC1945)
  594.         
  595.         // status-line ‡ rÈcupÈrer
  596.         finput(soc,rcvd,1024);
  597.         if (strnotempty(rcvd)==0)
  598.           finput(soc,rcvd,1024);    // "certains serveurs buggÈs envoient un \n au dÈbut" (RFC)
  599.  
  600.         // traiter status-line
  601.         treatfirstline(retour,rcvd);
  602.  
  603. #if HDEBUG
  604.         printf("Status-Code=%d\n",retour->statuscode);
  605. #endif
  606.         
  607.         // en-tÍte
  608.         
  609.         // header // ** !attention! HTTP/0.9 non supportÈ
  610.         do {
  611.           finput(soc,rcvd,1024);          
  612. #if HDEBUG
  613.           printf(">%s\n",rcvd);      
  614. #endif
  615.           if (strnotempty(rcvd))
  616.             treathead(NULL,NULL,NULL,retour,rcvd);  // traiter
  617.  
  618.         } while(strnotempty(rcvd));
  619.         
  620.         //rcvsize=-1;    // forCER CHARGEMENT INCONNU
  621.         
  622.         //if (retour)
  623.         //  retour->totalsize=rcvsize;
  624.         
  625.       } else { // si GET, on recevra l'en tÍte APRES
  626.         //rcvsize=-1;    // on ne connait pas la taille de l'en-tÍte
  627.         if (retour)
  628.           retour->totalsize=-1;
  629.       }
  630.       
  631.     }
  632.  
  633.   }
  634.     
  635.   return soc;
  636. }
  637.  
  638.  
  639. // envoi d'une requËte
  640. int http_sendhead(t_cookie* cookie,int mode,char* xsend,char* adr,char* fil,char* referer_adr,char* referer_fil,htsblk* retour) {
  641.   char buff[8192];
  642.   //int use_11=0;     // HTTP 1.1 utilisÈ
  643.   int direct_url=0; // ne pas analyser l'url (exemple: ftp://)
  644.   char* search_tag=NULL;
  645.   buff[0]='\0';
  646.  
  647.   // header Date
  648.   //strcatbuff(buff,"Date: ");
  649.   //time_gmt_rfc822(buff);    // obtenir l'heure au format rfc822
  650.   //sendc("\n");
  651.   //strcatbuff(buff,buff);
  652.  
  653.   // possibilitÈ non documentÈe: >post: et >postfile:
  654.   // si prÈsence d'un tag >post: alors executer un POST
  655.   // exemple: http://www.someweb.com/test.cgi?foo>post:posteddata=10&foo=5
  656.   // si prÈsence d'un tag >postfile: alors envoyer en tÍte brut contenu dans le fichier en question
  657.   // exemple: http://www.someweb.com/test.cgi?foo>postfile:post0.txt
  658.   search_tag=strstr(fil,POSTTOK":");
  659.   if (!search_tag) {
  660.     search_tag=strstr(fil,POSTTOK"file:");
  661.     if (search_tag) {     // postfile
  662.       if (mode==0) {      // GET!
  663.         FILE* fp=fopen(unescape_http(search_tag+strlen(POSTTOK)+5),"rb");
  664.         if (fp) {
  665.           char line[1100];
  666.           char protocol[256],url[HTS_URLMAXSIZE*2],method[256];
  667.           linput(fp,line,1000);
  668.           if (sscanf(line,"%s %s %s",method,url,protocol) == 3) {
  669.             // selon que l'on a ou pas un proxy
  670.             if (retour->req.proxy.active)
  671.               sprintf(buff,"%s http://%s%s %s\r\n",method,adr,url,protocol);
  672.             else
  673.               sprintf(buff,"%s %s %s\r\n",method,url,protocol);
  674.             // lire le reste en brut
  675.             fread(buff+strlen(buff),8000-strlen(buff),1,fp);
  676.           }
  677.           fclose(fp);
  678.         }
  679.       }
  680.     }
  681.   }
  682.   // Fin postfile
  683.   
  684.   if (strnotempty(buff)==0) {    // PAS POSTFILE
  685.     // Type de requËte?
  686.     if ((search_tag) && (mode==0)) {
  687.       strcatbuff(buff,"POST ");
  688.     } else if (mode==0) {    // GET
  689.       strcatbuff(buff,"GET ");
  690.     } else {  // if (mode==1) {
  691.       if (!retour->req.http11)        // forcer HTTP/1.0
  692.         strcatbuff(buff,"GET ");      // certains serveurs (cgi) buggent avec HEAD
  693.       else
  694.         strcatbuff(buff,"HEAD ");
  695.     }
  696.     
  697.     // si on gËre un proxy, il faut une Absolute URI: on ajoute avant http://www.adr.dom
  698.     if ( retour->req.proxy.active && (strncmp(adr,"https://", 8) != 0) ) {
  699.       if (!link_has_authority(adr)) {  // default http
  700. #if HDEBUG
  701.         printf("Proxy Use: for %s%s proxy %d port %d\n",adr,fil,retour->req.proxy.name,retour->req.proxy.port);
  702. #endif
  703.         strcatbuff(buff,"http://");
  704.         strcatbuff(buff,jump_identification(adr));
  705.       } else {          // ftp:// en proxy http
  706. #if HDEBUG
  707.         printf("Proxy Use for ftp: for %s%s proxy %d port %d\n",adr,fil,retour->req.proxy.name,retour->req.proxy.port);
  708. #endif
  709.         direct_url=1;             // ne pas analyser user/pass
  710.         strcatbuff(buff,adr);
  711.       }
  712.     } 
  713.     
  714.     // NOM DU FICHIER
  715.     // on slash doit Ítre prÈsent en dÈbut, sinon attention aux bad request! (400)
  716.     if (*fil!='/') strcatbuff(buff,"/");
  717.     {
  718.       char tempo[HTS_URLMAXSIZE*2];
  719.       tempo[0]='\0';
  720.       if (search_tag)
  721.         strncatbuff(tempo,fil,(int) (search_tag - fil));
  722.       else
  723.         strcpybuff(tempo,fil);
  724.       escape_check_url(tempo);
  725.       strcatbuff(buff,tempo);       // avec Èchappement
  726.     }
  727.     
  728.     // protocole
  729.     if (!retour->req.http11) {     // forcer HTTP/1.0
  730.       //use_11=0;
  731.       strcatbuff(buff," HTTP/1.0\x0d\x0a");
  732.     } else {                   // RequËte 1.1
  733.       //use_11=1;
  734.       strcatbuff(buff," HTTP/1.1\x0d\x0a");
  735.     }
  736.  
  737.     /* supplemental data */
  738.     if (xsend) strcatbuff(buff,xsend);    // Èventuelles autres lignes
  739.  
  740.     // tester proxy authentication
  741.     if (retour->req.proxy.active) {
  742.       if (link_has_authorization(retour->req.proxy.name)) {  // et hop, authentification proxy!
  743.         char* a=jump_identification(retour->req.proxy.name);
  744.         char* astart=jump_protocol(retour->req.proxy.name);
  745.         char autorisation[1100];
  746.         char user_pass[256];        
  747.         autorisation[0]=user_pass[0]='\0';
  748.         //
  749.         strncatbuff(user_pass,astart,(int) (a - astart) - 1);
  750.         strcpybuff(user_pass,unescape_http(user_pass));
  751.         code64(user_pass,autorisation);
  752.         strcatbuff(buff,"Proxy-Authorization: Basic ");
  753.         strcatbuff(buff,autorisation);
  754.         strcatbuff(buff,H_CRLF);
  755. #if HDEBUG
  756.         printf("Proxy-Authenticate, %s (code: %s)\n",user_pass,autorisation);
  757. #endif
  758.       }
  759.     }
  760.     
  761.     // Referer?
  762.     if ((referer_adr) && (referer_fil)) {       // existe
  763.       if ((strnotempty(referer_adr)) && (strnotempty(referer_fil))) {   // non vide
  764.         if (
  765.           (strcmp(referer_adr,"file://") != 0)
  766.           &&
  767.           (  /* no https referer to http urls */
  768.             (strncmp(referer_adr, "https://", 8) != 0)  /* referer is not https */
  769.             ||
  770.             (strncmp(adr, "https://", 8) == 0)          /* or referer AND addresses are https */
  771.           )
  772.           ) {      // PAS file://
  773.           strcatbuff(buff,"Referer: ");
  774.           strcatbuff(buff,"http://");
  775.           strcatbuff(buff,jump_identification(referer_adr));
  776.           strcatbuff(buff,referer_fil);
  777.           strcatbuff(buff,H_CRLF);
  778.         }
  779.       }
  780.     }
  781.     
  782.     // POST?
  783.     if (mode==0) {      // GET!
  784.       if (search_tag) {
  785.         char clen[256];
  786.         sprintf(clen,"Content-length: %d"H_CRLF,(int)(strlen(unescape_http(search_tag+strlen(POSTTOK)+1))));
  787.         strcatbuff(buff,clen);
  788.       }
  789.     }
  790.     
  791.     // gestion cookies?
  792.     if (cookie) {
  793.       char* b=cookie->data;
  794.       int cook=0;
  795.       int max_cookies=8;
  796.       int max_size=2048;
  797.       max_size+=strlen(buff);
  798.       do {
  799.         b=cookie_find(b,"",jump_identification(adr),fil);       // prochain cookie satisfaisant aux conditions
  800.         if (b) {
  801.           max_cookies--;
  802.           if (!cook) {
  803.             strcatbuff(buff,"Cookie: ");
  804.             strcatbuff(buff,"$Version=1; ");
  805.             cook=1;
  806.           } else
  807.             strcatbuff(buff,"; ");
  808.           strcatbuff(buff,cookie_get(b,5));
  809.           strcatbuff(buff,"=");
  810.           strcatbuff(buff,cookie_get(b,6));
  811.           strcatbuff(buff,"; $Path=");
  812.           strcatbuff(buff,cookie_get(b,2));
  813.           b=cookie_nextfield(b);
  814.         }
  815.       } while( (b) && (max_cookies>0) && ((int)strlen(buff)<max_size));
  816.       if (cook) {                           // on a envoyÈ un (ou plusieurs) cookie?
  817.         strcatbuff(buff,H_CRLF);
  818. #if DEBUG_COOK
  819.         printf("Header:\n%s\n",buff);
  820. #endif
  821.       }
  822.     }
  823.     
  824.     // connection close?
  825.     //if (use_11)     // Si on envoie une requËte 1.1, prÈciser qu'on ne veut pas de keep-alive!!
  826.     strcatbuff(buff,"Connection: close"H_CRLF);
  827.     
  828.     // gÈrer le keep-alive (garder socket)
  829.     //strcatbuff(buff,"Connection: Keep-Alive\n");
  830.     
  831.     {
  832.       char* real_adr=jump_identification(adr);
  833.       //if ((use_11) || (retour->user_agent_send)) {   // Pour le 1.1 on utilise un Host:
  834.       if (!direct_url) {     // pas ftp:// par exemple
  835.         //if (!retour->req.proxy.active) {
  836.         strcatbuff(buff,"Host: "); strcatbuff(buff,real_adr); strcatbuff(buff,H_CRLF);
  837.         //}
  838.       }
  839.       //}
  840.  
  841.       // PrÈsence d'un user-agent?
  842.       if (retour->req.user_agent_send) {  // ohh un user-agent
  843.         char s[256];
  844.         // HyperTextSeeker/"HTSVERSION
  845.         sprintf(s,"User-Agent: %s"H_CRLF,retour->req.user_agent);
  846.         strcatbuff(buff,s);
  847.         
  848.         // pour les serveurs difficiles
  849.         strcatbuff(buff,"Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, image/svg+xml, */*"H_CRLF);
  850.         if (strnotempty(retour->req.lang_iso)) {
  851.           strcatbuff(buff,"Accept-Language: "); strcatbuff(buff,retour->req.lang_iso); strcatbuff(buff,H_CRLF);
  852.         }
  853.         strcatbuff(buff,"Accept-Charset: iso-8859-1, *"H_CRLF);   
  854.         if (retour->req.http11) {
  855. #if HTS_USEZLIB
  856.           if ((!retour->req.range_used) && (!retour->req.nocompression))
  857.             strcatbuff(buff,"Accept-Encoding: gzip, deflate, compress, identity"H_CRLF);
  858.           else
  859.             strcatbuff(buff,"Accept-Encoding: identity"H_CRLF);       /* no compression */
  860. #else
  861.           strcatbuff(buff,"Accept-Encoding: identity"H_CRLF);         /* no compression */
  862. #endif
  863.         }
  864.       } else {
  865.         strcatbuff(buff,"Accept: */*"H_CRLF);         // le minimum
  866.       }
  867.  
  868.       /* Authentification */
  869.       {
  870.         char autorisation[1100];
  871.         char* a;
  872.         autorisation[0]='\0';
  873.         if (link_has_authorization(adr)) {  // ohh une authentification!
  874.           char* a=jump_identification(adr);
  875.           char* astart=jump_protocol(adr);
  876.           if (!direct_url) {      // pas ftp:// par exemple
  877.             char user_pass[256];
  878.             user_pass[0]='\0';
  879.             strncatbuff(user_pass,astart,(int) (a - astart) - 1);
  880.             strcpybuff(user_pass,unescape_http(user_pass));
  881.             code64(user_pass,autorisation);
  882.             if (strcmp(fil,"/robots.txt"))      /* pas robots.txt */
  883.               bauth_add(cookie,astart,fil,autorisation);
  884.           }
  885.         } else if ( (a=bauth_check(cookie,real_adr,fil)) )
  886.           strcpybuff(autorisation,a);
  887.         /* On a une autorisation a donner?  */
  888.         if (strnotempty(autorisation)) {
  889.           strcatbuff(buff,"Authorization: Basic ");
  890.           strcatbuff(buff,autorisation);
  891.           strcatbuff(buff,H_CRLF);
  892.         }
  893.       }
  894.  
  895.     }
  896.     //strcatbuff(buff,"Accept-Language: en\n");
  897.     //strcatbuff(buff,"Accept-Charset: iso-8859-1,*,utf-8\n");
  898.     
  899.     // CRLF de fin d'en tÍte
  900.     strcatbuff(buff,H_CRLF);
  901.     
  902.     // donnÈes complÈmentaires?
  903.     if (search_tag)
  904.     if (mode==0)      // GET!
  905.       strcatbuff(buff,unescape_http(search_tag+strlen(POSTTOK)+1));
  906.   }
  907.   
  908. #if HDEBUG
  909. #endif
  910.   if (_DEBUG_HEAD) {
  911.     if (ioinfo) {
  912.       fprintf(ioinfo,"request for %s%s:\r\n",jump_identification(adr),fil);
  913.       fprintfio(ioinfo,buff,"<<< ");
  914.       fprintf(ioinfo,"\r\n");
  915.       fflush(ioinfo);
  916.     }
  917.   }  // Fin test pas postfile
  918.   //
  919.  
  920.   // Envoi
  921.   if (sendc(retour, buff)<0) {  // ERREUR, socket rompue?...
  922.   //if (sendc(retour->soc,buff) != strlen(buff)) {  // ERREUR, socket rompue?...
  923.     deletesoc_r(retour);  // fermer tout de mÍme
  924.     // et tenter de reconnecter
  925.     
  926.     strcpybuff(retour->msg,"Broken pipe");
  927.     retour->soc=INVALID_SOCKET;
  928.   }
  929.   
  930.   // RX'98
  931.   return 0;
  932. }
  933.  
  934.  
  935.  
  936.  
  937. // traiter 1ere ligne d'en tÍte
  938. void treatfirstline(htsblk* retour,char* rcvd) {
  939.   char* a=rcvd;
  940.   // exemple:
  941.   // HTTP/1.0 200 OK
  942.   if (*a) {
  943.     // note: certains serveurs buggÈs renvoient HTTP/1.0\n200 OK ou " HTTP/1.0 200 OK"
  944.     while ((*a==' ') || (*a==10) || (*a==13) || (*a==9)) a++;      // Èpurer espaces au dÈbut
  945.     if (strfield(a, "HTTP/")) {
  946.       // sauter HTTP/1.x
  947.       while ((*a!=' ') && (*a!='\0') && (*a!=10) && (*a!=13) && (*a!=9)) a++;   
  948.       if (*a != '\0') {
  949.         while ((*a==' ') || (*a==10) || (*a==13) || (*a==9)) a++;      // Èpurer espaces
  950.         if ((*a>='0') && (*a<='9')) {
  951.           sscanf(a,"%d",&(retour->statuscode));
  952.           // sauter 200
  953.           while ((*a!=' ') && (*a!='\0') && (*a!=10) && (*a!=13) && (*a!=9)) a++;   
  954.           while ((*a==' ') || (*a==10) || (*a==13) || (*a==9)) a++;      // Èpurer espaces
  955.           if ((strlen(a) > 1) && (strlen(a) < 64) )                // message retour
  956.             strcpybuff(retour->msg,a);
  957.           else
  958.             infostatuscode(retour->msg,retour->statuscode);
  959.           // type MIME par dÈfaut2
  960.           strcpybuff(retour->contenttype,HTS_HYPERTEXT_DEFAULT_MIME);
  961.         } else {  // pas de code!
  962.           retour->statuscode=-1;
  963.           strcpybuff(retour->msg,"Unknown response structure");
  964.         }
  965.       } else {  // euhh??
  966.         retour->statuscode=-1;
  967.         strcpybuff(retour->msg,"Unknown response structure");
  968.       }
  969.     } else {
  970.             if (*a == '<') {
  971.         /* This is dirty .. */
  972.         retour->statuscode=200;
  973.         strcpybuff(retour->msg, "Unknown, assuming junky server");
  974.         strcpybuff(retour->contenttype,HTS_HYPERTEXT_DEFAULT_MIME);
  975.             } else if (strnotempty(a)) {
  976.         retour->statuscode=-1;
  977.         strcpybuff(retour->msg,"Unknown response structure, no HTTP/ response given");
  978.       } else {
  979.         /* This is dirty .. */
  980.         retour->statuscode=200;
  981.         strcpybuff(retour->msg, "Unknown, assuming junky server");
  982.         strcpybuff(retour->contenttype,HTS_HYPERTEXT_DEFAULT_MIME);
  983.       }
  984.     }
  985.   } else {  // vide!
  986.     /*
  987.     retour->statuscode=-1;
  988.     strcpybuff(retour->msg,"Empty reponse or internal error");
  989.     */
  990.     /* This is dirty .. */
  991.     retour->statuscode=200;
  992.     strcpybuff(retour->msg, "Unknown, assuming junky server");
  993.     strcpybuff(retour->contenttype,HTS_HYPERTEXT_DEFAULT_MIME);
  994.   }
  995. }
  996.  
  997. // traiter ligne par ligne l'en tÍte
  998. // gestion des cookies
  999. void treathead(t_cookie* cookie,char* adr,char* fil,htsblk* retour,char* rcvd) {
  1000.   int p;
  1001.   if ((p=strfield(rcvd,"Content-length:"))!=0) {
  1002. #if HDEBUG
  1003.     printf("ok, Content-length: dÈtectÈ\n");
  1004. #endif
  1005.     sscanf(rcvd+p,LLintP,&(retour->totalsize));
  1006.     if (retour->totalsize == 0) {
  1007.       retour->empty = 1;
  1008.     }
  1009.   }
  1010.   else if ((p=strfield(rcvd,"Content-Disposition:"))!=0) {
  1011.     while(*(rcvd+p)==' ') p++;    // sauter espaces
  1012.     if ((int) strlen(rcvd+p)<250) { // pas trop long?
  1013.       char tmp[256];
  1014.       char *a=NULL,*b=NULL;
  1015.       strcpybuff(tmp,rcvd+p);
  1016.       a=strstr(tmp,"filename=");
  1017.       if (a) {
  1018.         a+=strlen("filename=");
  1019.         while(is_space(*a)) a++;
  1020.         //a=strchr(a,'"');
  1021.         if (a) {
  1022.           char *c=NULL;
  1023.           //a++;      /* jump " */
  1024.           while((c=strchr(a,'/')))    /* skip all / (see RFC2616) */
  1025.             a=c+1;
  1026.           //b=strchr(a+1,'"');
  1027.           b=a+strlen(a)-1;
  1028.           while(is_space(*b)) b--;
  1029.           b++;
  1030.           if (b) {
  1031.             *b='\0';
  1032.             if ((int) strlen(a) < 200) { // pas trop long?
  1033.               strcpybuff(retour->cdispo,a);
  1034.             }
  1035.           }
  1036.         }
  1037.       } 
  1038.     }
  1039.   }
  1040.   else if ((p=strfield(rcvd,"Last-Modified:"))!=0) {
  1041.     while(*(rcvd+p)==' ') p++;    // sauter espaces
  1042.     if ((int) strlen(rcvd+p)<64) { // pas trop long?
  1043.       //struct tm* tm_time=convert_time_rfc822(rcvd+p);
  1044.       strcpybuff(retour->lastmodified,rcvd+p);
  1045.     }
  1046.   }
  1047.   else if ((p=strfield(rcvd,"Date:"))!=0) {
  1048.     if (strnotempty(retour->lastmodified)==0) {          /* pas encore de last-modified */
  1049.       while(*(rcvd+p)==' ') p++;    // sauter espaces
  1050.       if ((int) strlen(rcvd+p)<64) { // pas trop long?
  1051.         //struct tm* tm_time=convert_time_rfc822(rcvd+p);
  1052.         strcpybuff(retour->lastmodified,rcvd+p);
  1053.       }
  1054.     }
  1055.   }
  1056.   else if ((p=strfield(rcvd,"Etag:"))!=0) {   /* Etag */
  1057.     if (retour) {
  1058.       while(*(rcvd+p)==' ') p++;    // sauter espaces
  1059.       if ((int) strlen(rcvd+p)<64)  // pas trop long?
  1060.         strcpybuff(retour->etag,rcvd+p);
  1061.       else    // erreur.. ignorer
  1062.         retour->etag[0]='\0';
  1063.     }
  1064.   }
  1065.   else if ((p=strfield(rcvd,"Transfer-Encoding: chunked"))!=0) {  // chunk!
  1066.     retour->is_chunk=1;     // chunked
  1067.     //retour->http11=2;     // chunked
  1068. #if HDEBUG
  1069.     printf("ok, Transfer-Encoding: dÈtectÈ\n");
  1070. #endif
  1071.   }
  1072.   else if ((p=strfield(rcvd,"Content-type:"))!=0) {
  1073.     if (retour) {
  1074.       char tempo[1100];
  1075.       // Èviter les text/html; charset=foo
  1076.       {
  1077.         char* a=strchr(rcvd+p,';');
  1078.         if (a) *a='\0';
  1079.       }
  1080.       sscanf(rcvd+p,"%s",tempo);
  1081.       if (strlen(tempo)<64)    // pas trop long!!
  1082.         strcpybuff(retour->contenttype,tempo);
  1083.       else
  1084.         strcpybuff(retour->contenttype,"application/octet-stream-unknown");    // erreur
  1085.     }
  1086.   }
  1087.   else if ((p=strfield(rcvd,"Content-Range:"))!=0) {
  1088.     char* a=strstr(rcvd+p,"*/");
  1089.     if (a) {
  1090.       if (sscanf(a+2,LLintP,&retour->crange) != 1) {
  1091.         retour->crange=0;
  1092.       }
  1093.     }
  1094.   }
  1095.   else if ((p=strfield(rcvd,"Content-Encoding:"))!=0) {
  1096.     if (retour) {
  1097.       char tempo[1100];
  1098.       {
  1099.         char* a=strchr(rcvd+p,';');
  1100.         if (a) *a='\0';
  1101.       }
  1102.       sscanf(rcvd+p,"%s",tempo);
  1103.       if (strlen(tempo)<64)    // pas trop long!!
  1104.         strcpybuff(retour->contentencoding,tempo);
  1105.       else
  1106.         retour->contentencoding[0]='\0';    // erreur
  1107. #if HTS_USEZLIB
  1108.       /* Check known encodings */
  1109.       if (retour->contentencoding[0]) {
  1110.         if (
  1111.           (strfield2(retour->contentencoding, "gzip"))
  1112.           || (strfield2(retour->contentencoding, "x-gzip"))
  1113.           /*
  1114.           || (strfield2(retour->contentencoding, "compress"))
  1115.           || (strfield2(retour->contentencoding, "x-compress"))
  1116.           */
  1117.           || (strfield2(retour->contentencoding, "deflate"))
  1118.           || (strfield2(retour->contentencoding, "x-deflate"))
  1119.           ) {
  1120.         retour->compressed=1;
  1121.         }
  1122.       }
  1123. #endif
  1124.     }
  1125.   }
  1126.   else if ((p=strfield(rcvd,"Location:"))!=0) {
  1127.     if (retour) {
  1128.       if (retour->location) {
  1129.         while(*(rcvd+p)==' ') p++;    // sauter espaces
  1130.         if ((int) strlen(rcvd+p)<HTS_URLMAXSIZE)  // pas trop long?
  1131.           strcpybuff(retour->location,rcvd+p);
  1132.         else    // erreur.. ignorer
  1133.           retour->location[0]='\0';
  1134.       }
  1135.     }
  1136.   }
  1137.   else if ((p=strfield(rcvd,"Connection: Keep-Alive"))!=0) {
  1138.     // non, pas de keep-alive! on dÈconnectera..          
  1139.   }
  1140.   else if ((p=strfield(rcvd,"Keep-Alive:"))!=0) {    // params keep-alive
  1141.     // rien ‡ faire          
  1142.   }
  1143.   else if ( ((p=strfield(rcvd,"Set-Cookie:"))!=0) && (cookie) ) {    // ohh un cookie
  1144.     char* a = rcvd+p;           // pointeur
  1145.     char domain[256];           // domaine cookie (.netscape.com)
  1146.     char path[256];             // chemin (/)
  1147.     char cook_name[256];        // nom cookie (MYCOOK)
  1148.     char cook_value[8192];      // valeur (ID=toto,S=1234)
  1149. #if DEBUG_COOK
  1150.     printf("set-cookie detected\n");
  1151. #endif
  1152.     while(*a) {
  1153.       char *token_st,*token_end;
  1154.       char *value_st,*value_end;
  1155.       char name[256];
  1156.       char value[8192];
  1157.       int next=0;
  1158.       name[0]=value[0]='\0';
  1159.       //
  1160.  
  1161.       // initialiser cookie lu actuellement
  1162.       if (adr)
  1163.         strcpybuff(domain,jump_identification(adr));     // domaine
  1164.       strcpybuff(path,"/");         // chemin (/)
  1165.       strcpybuff(cook_name,"");     // nom cookie (MYCOOK)
  1166.       strcpybuff(cook_value,"");    // valeur (ID=toto,S=1234)
  1167.       // boucler jusqu'au prochain cookie ou la fin
  1168.       do {
  1169.         char* start_loop=a;
  1170.         while(is_space(*a)) a++;    // sauter espaces
  1171.         token_st=a;                 // dÈpart token
  1172.         while((!is_space(*a)) && (*a) && (*a!=';') && (*a!='=')) a++;    // arrÍter si espace, point virgule
  1173.         token_end=a;
  1174.         while(is_space(*a)) a++;    // sauter espaces
  1175.         if (*a=='=') {    // name=value
  1176.           a++;
  1177.           while(is_space(*a)) a++;    // sauter espaces
  1178.           value_st=a;
  1179.           while( (*a!=';') && (*a)) a++;    // prochain ;
  1180.           //while( ((*a!='"') || (*(a-1)=='\\')) && (*a)) a++;    // prochain " (et pas \")
  1181.           value_end=a;
  1182.           //if (*a==';') {  // finit par un ;
  1183.           // vÈrifier dÈbordements
  1184.           if ( (((int) (token_end - token_st))<200) && (((int) (value_end - value_st))<8000)
  1185.             && (((int) (token_end - token_st))>0)   && (((int) (value_end - value_st))>0) ) {
  1186.             name[0]='\0';
  1187.             value[0]='\0';
  1188.             strncatbuff(name,token_st,(int) (token_end - token_st));
  1189.             strncatbuff(value,value_st,(int) (value_end - value_st));
  1190. #if DEBUG_COOK
  1191.             printf("detected cookie-av: name=\"%s\" value=\"%s\"\n",name,value);
  1192. #endif
  1193.             if (strfield2(name,"domain")) {
  1194.               strcpybuff(domain,value);
  1195.             }
  1196.             else if (strfield2(name,"path")) {
  1197.               strcpybuff(path,value);
  1198.             }
  1199.             else if (strfield2(name,"max-age")) {
  1200.               // ignorÈ..
  1201.             }
  1202.             else if (strfield2(name,"expires")) {
  1203.               // ignorÈ..
  1204.             }
  1205.             else if (strfield2(name,"version")) {
  1206.               // ignorÈ..
  1207.             }
  1208.             else if (strfield2(name,"comment")) {
  1209.               // ignorÈ
  1210.             }
  1211.             else if (strfield2(name,"secure")) {    // ne devrait pas arriver ici
  1212.               // ignorÈ
  1213.             }
  1214.             else {
  1215.               if (strnotempty(cook_name)==0) {          // noter premier: nom et valeur cookie
  1216.                 strcpybuff(cook_name,name);
  1217.                 strcpybuff(cook_value,value);
  1218.               } else {                             // prochain cookie
  1219.                 a=start_loop;      // on devra recommencer ‡ cette position
  1220.                 next=1;            // enregistrer
  1221.               }
  1222.             }
  1223.           }
  1224.         }
  1225.         if (!next) {
  1226.           while((*a!=';') && (*a)) a++;    // prochain
  1227.           while(*a==';') a++;             // sauter ;
  1228.         }
  1229.       } while((*a) && (!next));
  1230.       if (strnotempty(cook_name)) {          // cookie?
  1231. #if DEBUG_COOK
  1232.         printf("new cookie: name=\"%s\" value=\"%s\" domain=\"%s\" path=\"%s\"\n",cook_name,cook_value,domain,path);
  1233. #endif
  1234.         cookie_add(cookie,cook_name,cook_value,domain,path);
  1235.       }
  1236.     }
  1237.   }
  1238. }
  1239.  
  1240.  
  1241. // transforme le message statuscode en chaÓne
  1242. HTSEXT_API void infostatuscode(char* msg,int statuscode) {
  1243.   switch( statuscode) {    
  1244.     // Erreurs HTTP, selon RFC
  1245.   case 100: strcpybuff( msg,"Continue"); break; 
  1246.   case 101: strcpybuff( msg,"Switching Protocols"); break; 
  1247.   case 200: strcpybuff( msg,"OK"); break; 
  1248.   case 201: strcpybuff( msg,"Created"); break; 
  1249.   case 202: strcpybuff( msg,"Accepted"); break; 
  1250.   case 203: strcpybuff( msg,"Non-Authoritative Information"); break; 
  1251.   case 204: strcpybuff( msg,"No Content"); break; 
  1252.   case 205: strcpybuff( msg,"Reset Content"); break; 
  1253.   case 206: strcpybuff( msg,"Partial Content"); break; 
  1254.   case 300: strcpybuff( msg,"Multiple Choices"); break; 
  1255.   case 301: strcpybuff( msg,"Moved Permanently"); break; 
  1256.   case 302: strcpybuff( msg,"Moved Temporarily"); break; 
  1257.   case 303: strcpybuff( msg,"See Other"); break; 
  1258.   case 304: strcpybuff( msg,"Not Modified"); break; 
  1259.   case 305: strcpybuff( msg,"Use Proxy"); break; 
  1260.   case 306: strcpybuff( msg,"Undefined 306 error"); break; 
  1261.   case 307: strcpybuff( msg,"Temporary Redirect"); break; 
  1262.   case 400: strcpybuff( msg,"Bad Request"); break; 
  1263.   case 401: strcpybuff( msg,"Unauthorized"); break; 
  1264.   case 402: strcpybuff( msg,"Payment Required"); break; 
  1265.   case 403: strcpybuff( msg,"Forbidden"); break; 
  1266.   case 404: strcpybuff( msg,"Not Found"); break; 
  1267.   case 405: strcpybuff( msg,"Method Not Allowed"); break; 
  1268.   case 406: strcpybuff( msg,"Not Acceptable"); break; 
  1269.   case 407: strcpybuff( msg,"Proxy Authentication Required"); break; 
  1270.   case 408: strcpybuff( msg,"Request Time-out"); break; 
  1271.   case 409: strcpybuff( msg,"Conflict"); break; 
  1272.   case 410: strcpybuff( msg,"Gone"); break; 
  1273.   case 411: strcpybuff( msg,"Length Required"); break; 
  1274.   case 412: strcpybuff( msg,"Precondition Failed"); break; 
  1275.   case 413: strcpybuff( msg,"Request Entity Too Large"); break; 
  1276.   case 414: strcpybuff( msg,"Request-URI Too Large"); break; 
  1277.   case 415: strcpybuff( msg,"Unsupported Media Type"); break; 
  1278.   case 416: strcpybuff( msg,"Requested Range Not Satisfiable"); break; 
  1279.   case 417: strcpybuff( msg,"Expectation Failed"); break; 
  1280.   case 500: strcpybuff( msg,"Internal Server Error"); break; 
  1281.   case 501: strcpybuff( msg,"Not Implemented"); break; 
  1282.   case 502: strcpybuff( msg,"Bad Gateway"); break; 
  1283.   case 503: strcpybuff( msg,"Service Unavailable"); break; 
  1284.   case 504: strcpybuff( msg,"Gateway Time-out"); break; 
  1285.   case 505: strcpybuff( msg,"HTTP Version Not Supported"); break; 
  1286.     //
  1287.   default: if (strnotempty(msg)==0) strcpybuff( msg,"Unknown error"); break;
  1288.   }
  1289. }
  1290.  
  1291.  
  1292. // identique au prÈcÈdent, sauf que l'on donne adr+fil et non url complËte
  1293. htsblk xhttpget(char* adr,char* fil) {
  1294.   T_SOC soc;
  1295.   htsblk retour;
  1296.   
  1297.   memset(&retour, 0, sizeof(htsblk));
  1298.   soc=http_fopen(adr,fil,&retour);
  1299.  
  1300.   if (soc!=INVALID_SOCKET) {
  1301.     http_fread(soc,&retour);
  1302. #if HTS_DEBUG_CLOSESOCK
  1303.     DEBUG_W("xhttpget: deletehttp\n");
  1304. #endif
  1305.     if (retour.soc!=INVALID_SOCKET) deletehttp(&retour);  // fermer
  1306.     retour.soc=INVALID_SOCKET;
  1307.   }
  1308.   return retour;
  1309. }
  1310.  
  1311. // variation sur un thËme...
  1312. // rÈceptionne uniquement un en-tÍte (HEAD)
  1313. // retourne dans xx.adr l'adresse pointant sur le bloc de mÈmoire de l'en tÍte
  1314. htsblk http_gethead(char* adr,char* fil) {
  1315.   T_SOC soc;
  1316.   htsblk retour;
  1317.  
  1318.   memset(&retour, 0, sizeof(htsblk));
  1319.   soc=http_xfopen(1,0,1,NULL,adr,fil,&retour);  // HEAD, pas de traitement en-tÍte
  1320.  
  1321.   if (soc!=INVALID_SOCKET) {
  1322.     http_fread(soc,&retour);    // rÈception en-tÍte
  1323. #if HTS_DEBUG_CLOSESOCK
  1324.     DEBUG_W("http_gethead: deletehttp\n");
  1325. #endif
  1326.     if (retour.soc!=INVALID_SOCKET) deletehttp(&retour);  // fermer
  1327.     retour.soc=INVALID_SOCKET;
  1328.   }
  1329.   return retour;
  1330. }
  1331. // oui ca ressemble vachement ‡ xhttpget - en Ètant sobre on peut voir LA diffÈrence..
  1332.  
  1333.  
  1334. // lecture sur une socket ouverte, le header a dÈja ÈtÈ envoyÈ dans le cas de GET
  1335. // il ne reste plus qu'‡ lire les donnÈes
  1336. // (pour HEAD le header est lu ici!)
  1337. void http_fread(T_SOC soc,htsblk* retour) {  
  1338.   //int bufl=TAILLE_BUFFER;    // 8Ko de buffer
  1339.   
  1340.   if (retour) retour->soc=soc;
  1341.   if (soc!=INVALID_SOCKET) {    
  1342.     // fonction de lecture d'une socket (plus propre)
  1343.     while(http_fread1(retour)!=-1);
  1344.     soc=retour->soc;
  1345.     if (retour->adr==NULL) {
  1346.       if (strnotempty(retour->msg)==0)
  1347.         sprintf(retour->msg,"Unable to read");
  1348.       return ;    // erreur
  1349.     } 
  1350.     
  1351. #if HDEBUG
  1352.     printf("Ok, donnÈes reÁues\n");
  1353. #endif   
  1354.  
  1355.     return ;
  1356.     
  1357.   } 
  1358.   
  1359.   return ;
  1360. }
  1361.  
  1362. // check if data is available
  1363. int check_readinput(htsblk* r) {
  1364.   if (r->soc != INVALID_SOCKET) {
  1365.     fd_set fds;           // poll structures
  1366.     struct timeval tv;          // structure for select
  1367.     FD_ZERO(&fds);
  1368.     FD_SET(r->soc,&fds);           
  1369.     tv.tv_sec=0;
  1370.     tv.tv_usec=0;
  1371.     select(r->soc + 1,&fds,NULL,NULL,&tv);
  1372.     if (FD_ISSET(r->soc,&fds))
  1373.       return 1;
  1374.     else
  1375.       return 0;
  1376.   } else
  1377.     return 0;
  1378. }
  1379.  
  1380. // lecture d'un bloc sur une socket (ou un fichier!)
  1381. // >=0 : nombre d'octets lus
  1382. // <0 : fin ou erreur
  1383. HTS_INLINE LLint http_fread1(htsblk* r) {
  1384.   //int bufl=TAILLE_BUFFER;  // taille d'un buffer max.
  1385.   return http_xfread1(r,TAILLE_BUFFER);
  1386. }
  1387.  
  1388. // idem, sauf qu'ici on peut choisir la taille max de donnÈes ‡ recevoir
  1389. // SI bufl==0 alors le buffer est censÈ Ítre de 8kos, et on recoit par bloc de lignes
  1390. // en Èliminant les cr (ex: header), arrÍt si double-lf
  1391. // SI bufl==-1 alors le buffer est censÈ Ítre de 8kos, et on recoit ligne par ligne
  1392. // en Èliminant les cr (ex: header), arrÍt si double-lf
  1393. // Note: les +1 dans les malloc sont d˚s ‡ l'octet nul rajoutÈ en fin de fichier
  1394. LLint http_xfread1(htsblk* r,int bufl) {
  1395.   int nl=-1;
  1396.  
  1397.   if (bufl>0) {
  1398.     if (!r->is_write) {     // stocker en mÈmoire
  1399.       if (r->totalsize>0) {    // totalsize dÈterminÈ ET ALLOUE
  1400.         if (r->adr==NULL) {
  1401.           r->adr=(char*) malloct((INTsys) r->totalsize + 1);
  1402.           r->size=0;
  1403.         }
  1404.         if (r->adr!=NULL) {
  1405.           // lecture
  1406.           nl = hts_read(r,r->adr + ((int) r->size),(int) (r->totalsize-r->size) );     /* NO 32 bit overlow possible here (no 4GB html!) */
  1407.           // nouvelle taille
  1408.           if (nl >= 0) r->size+=nl;
  1409.           
  1410.           if ((nl < 0) || (r->size >= r->totalsize))
  1411.             nl=-1;  // break
  1412.           
  1413.           r->adr[r->size]='\0';    // caractËre NULL en fin au cas o˘ l'on traite des HTML
  1414.         }
  1415.         
  1416.       } else {                 // inconnu..
  1417.         // rÈserver de la mÈmoire?
  1418.         if (r->adr==NULL) {
  1419. #if HDEBUG
  1420.           printf("..alloc xfread\n");
  1421. #endif
  1422.           r->adr=(char*) malloct(bufl + 1);
  1423.           r->size=0;
  1424.         }
  1425.         else {
  1426. #if HDEBUG
  1427.           printf("..realloc xfread1\n");
  1428. #endif
  1429.           r->adr=(char*) realloct(r->adr,(int)r->size+bufl + 1);
  1430.         }
  1431.         
  1432.         if (r->adr!=NULL) {
  1433.           // lecture
  1434.           nl = hts_read(r,r->adr+(int)r->size,bufl);
  1435.           if (nl>0) {
  1436.             // resize
  1437.             r->adr=(char*) realloct(r->adr,(int)r->size+nl + 1);
  1438.             // nouvelle taille
  1439.             r->size+=nl;
  1440.             // octet nul
  1441.             if (r->adr) r->adr[r->size]='\0';
  1442.  
  1443.           } // sinon on a fini
  1444. #if HDEBUG
  1445.           else if (nl < 0)
  1446.             printf("..end read (%d)\n", nl);
  1447. #endif
  1448.         }
  1449. #if HDEBUG
  1450.         else printf("..-> error\n");
  1451. #endif
  1452.       }
  1453.  
  1454.       // pas de adr=erreur
  1455.       if (r->adr==NULL) nl=-1;
  1456.  
  1457.     } else {    // stocker sur disque
  1458.       char* buff;
  1459.       buff=(char*) malloct(bufl);
  1460.       if (buff!=NULL) {
  1461.         // lecture
  1462.         nl = hts_read(r,buff,bufl);
  1463.         // nouvelle taille
  1464.         if (nl > 0) { 
  1465.           r->size+=nl;
  1466.           if ((int) fwrite(buff,1,nl,r->out)!=nl) {
  1467.             r->statuscode=-1;
  1468.             strcpybuff(r->msg,"Write error on disk");
  1469.             nl=-1;
  1470.           }
  1471.         }
  1472.  
  1473.         if ((nl < 0) || ((r->totalsize>0) && (r->size >= r->totalsize)))
  1474.           nl=-1;  // break
  1475.  
  1476.         // libÈrer bloc tempo
  1477.         freet(buff);
  1478.       } else
  1479.         nl=-1;
  1480.       
  1481.       if ((nl < 0) && (r->out!=NULL)) {
  1482.         fflush(r->out); 
  1483.       }
  1484.         
  1485.         
  1486.     } // stockage disque ou mÈmoire
  1487.  
  1488.   } else if (bufl == -2) {  // force reserve
  1489.     if (r->adr==NULL) {
  1490.       r->adr=(char*) malloct(8192);
  1491.       r->size=0;
  1492.       return 0;
  1493.     }
  1494.     return -1;
  1495.   } else {    // rÈception d'un en-tÍte octet par octet
  1496.     int count=256;
  1497.     int tot_nl=0;
  1498.     int lf_detected=0;
  1499.     int at_begining=1;
  1500.     do {
  1501.       nl=-1;
  1502.       count--;
  1503.       if (r->adr==NULL) {
  1504.         r->adr=(char*) malloct(8192);
  1505.         r->size=0;
  1506.       }
  1507.       if (r->adr!=NULL) {
  1508.         if (r->size < 8190) {
  1509.           // lecture
  1510.           nl = hts_read(r,r->adr+r->size,1);
  1511.           if (nl>0) {
  1512.             // exit if:
  1513.             // lf detected AND already detected before
  1514.             // or
  1515.             // lf detected AND first character read
  1516.             if (*(r->adr+r->size) == 10) {
  1517.               if (lf_detected || (at_begining) || (bufl<0))
  1518.                 count=-1;
  1519.               lf_detected=1;
  1520.             }
  1521.             if (*(r->adr+r->size) != 13) {   // sauter caractËres 13
  1522.               if (
  1523.                 (*(r->adr+r->size) != 10)
  1524.                 &&
  1525.                 (*(r->adr+r->size) != 13)
  1526.                 ) {
  1527.                 // restart for new line
  1528.                 lf_detected=0;
  1529.               }
  1530.               (r->size)++;
  1531.               at_begining=0;
  1532.             }
  1533.             *(r->adr+r->size)='\0';    // terminer par octet nul
  1534.           }
  1535.         }
  1536.       }
  1537.       if (nl >= 0) {
  1538.         tot_nl+=nl;
  1539.         if (!check_readinput(r))
  1540.           count=-1;
  1541.       }
  1542.     } while((nl >= 0) && (count>0));
  1543.     nl = tot_nl;
  1544.   }
  1545. #if HDEBUG
  1546.   //printf("add to %d / %d\n",r->size,r->totalsize);
  1547. #endif
  1548.   // nl == 0 may mean "no relevant data", for example is using cache or ssl
  1549. #if HTS_USEOPENSSL
  1550.   if (r->ssl)
  1551.     return nl;
  1552.   else
  1553. #endif
  1554.     return ((nl > 0) ? nl : -1);        // ==0 is fatal if direct read
  1555. }
  1556.  
  1557.  
  1558. // teste une adresse, et suit l'Èventuel chemin "moved"
  1559. // retourne 200 ou le code d'erreur (404=NOT FOUND, etc)
  1560. // copie dans loc la vÈritable adresse si celle-ci est diffÈrente
  1561. htsblk http_location(char* adr,char* fil,char* loc) {
  1562.   htsblk retour;
  1563.   int retry=0;
  1564.   int tryagain;
  1565.   // note: "RFC says"
  1566.   // 5 boucles au plus, on en teste au plus 8 ici
  1567.   // sinon abandon..
  1568.   do {
  1569.     tryagain=0;
  1570.     switch ((retour=http_test(adr,fil,loc)).statuscode) {
  1571.     case 200: break;   // ok!
  1572.     case 301: case 302: case 303: case 307: // moved!
  1573.       // recalculer adr et fil!
  1574.       if (ident_url_absolute(loc,adr,fil)!=-1) {
  1575.         tryagain=1;  // retenter
  1576.         retry++;     // ..encore une fois
  1577.       }
  1578.     }
  1579.   } while((tryagain) && (retry<5+3));
  1580.   return retour;
  1581. }
  1582.  
  1583.  
  1584. // teste si une URL (validitÈ, header, taille)
  1585. // retourne 200 ou le code d'erreur (404=NOT FOUND, etc)
  1586. // en cas de moved xx, dans location
  1587. // abandonne dÈsormais au bout de 30 secondes (aurevoir les sites
  1588. // qui nous font poireauter 5 heures..) -> -2=timeout
  1589. htsblk http_test(char* adr,char* fil,char* loc) {
  1590.   T_SOC soc;
  1591.   htsblk retour;
  1592.   //int rcvsize=-1;
  1593.   //char* rcv=NULL;    // adresse de retour
  1594.   //int bufl=TAILLE_BUFFER;    // 8Ko de buffer
  1595.   TStamp tl;
  1596.   int timeout=30;  // timeout pour un check (arbitraire) // **
  1597.  
  1598.   // pour abandonner un site trop lent
  1599.   tl=time_local();
  1600.  
  1601.   loc[0]='\0';
  1602.   memset(&retour, 0, sizeof(htsblk));    // effacer
  1603.   retour.location=loc;    // si non nul, contiendra l'adresse vÈritable en cas de moved xx
  1604.  
  1605.   //soc=http_fopen(adr,fil,&retour,NULL);  // ouvrir, + header
  1606.  
  1607.   // on ouvre en head, et on traite l'en tÍte
  1608.   soc=http_xfopen(1,0,1,NULL,adr,fil,&retour);  // ouvrir HEAD, + envoi header
  1609.   
  1610.   if (soc!=INVALID_SOCKET) {
  1611.     int e=0;
  1612.     // tant qu'on a des donnÈes, et qu'on ne recoit pas deux LF, et que le timeout n'arrie pas
  1613.     do {
  1614.       if (http_xfread1(&retour,0) < 0)
  1615.         e=1;
  1616.       else {
  1617.         if (retour.adr!=NULL) {
  1618.           if ((retour.adr[retour.size-1]!=10) || (retour.adr[retour.size-2]!=10))
  1619.             e=1;
  1620.         }
  1621.       }
  1622.             
  1623.       if (!e) {
  1624.         if ((time_local()-tl)>=timeout) {
  1625.           e=-1;
  1626.         }
  1627.       }
  1628.       
  1629.     } while (!e);
  1630.     
  1631.     if (e==1) {
  1632.       if (adr!=NULL) {
  1633.         int ptr=0;
  1634.         char rcvd[1100];
  1635.  
  1636.         // note: en gros recopie du traitement de back_wait()
  1637.         //
  1638.  
  1639.  
  1640.         // ----------------------------------------
  1641.         // traiter en-tÍte!
  1642.         // status-line ‡ rÈcupÈrer
  1643.         ptr+=binput(retour.adr+ptr,rcvd,1024);
  1644.         if (strnotempty(rcvd)==0)
  1645.           ptr+=binput(retour.adr+ptr,rcvd,1024);    // "certains serveurs buggÈs envoient un \n au dÈbut" (RFC)
  1646.         
  1647.         // traiter status-line
  1648.         treatfirstline(&retour,rcvd);
  1649.         
  1650. #if HDEBUG
  1651.         printf("(Buffer) Status-Code=%d\n",retour.statuscode);
  1652. #endif
  1653.         
  1654.         // en-tÍte
  1655.         
  1656.         // header // ** !attention! HTTP/0.9 non supportÈ
  1657.         do {
  1658.           ptr+=binput(retour.adr+ptr,rcvd,1024);          
  1659. #if HDEBUG
  1660.           printf("(buffer)>%s\n",rcvd);      
  1661. #endif
  1662.           if (strnotempty(rcvd))
  1663.             treathead(NULL,NULL,NULL,&retour,rcvd);  // traiter
  1664.           
  1665.         } while(strnotempty(rcvd));
  1666.         // ----------------------------------------                    
  1667.         
  1668.         // libÈrer mÈmoire
  1669.         if (retour.adr!=NULL) { freet(retour.adr); retour.adr=NULL; }
  1670.       }
  1671.     } else {
  1672.       retour.statuscode=-2;
  1673.       strcpybuff(retour.msg,"Timeout While Testing");
  1674.     }
  1675.     
  1676.     
  1677. #if HTS_DEBUG_CLOSESOCK
  1678.     DEBUG_W("http_test: deletehttp\n");
  1679. #endif
  1680.     deletehttp(&retour);
  1681.     retour.soc=INVALID_SOCKET;
  1682.   }
  1683.   return retour;    
  1684. }
  1685.  
  1686. // CrÈe un lien (http) vers une adresse internet iadr
  1687. // retour: structure (adresse, taille, message si erreur (si !adr))
  1688. // peut ouvrir avec des connect() non bloquants: waitconnect=0/1
  1689. int newhttp(char* _iadr,htsblk* retour,int port,int waitconnect) {  
  1690.   t_fullhostent fullhostent_buffer;    // buffer pour resolver
  1691.   T_SOC soc;                           // descipteur de la socket
  1692.   char* iadr;
  1693.   // unsigned short int port;
  1694.   
  1695.   // tester un Èventuel id:pass et virer id:pass@ si dÈtectÈ
  1696.   iadr = jump_identification(_iadr);
  1697.   
  1698.   // si iadr="#" alors c'est une fausse URL, mais un vrai fichier
  1699.   // local.
  1700.   // utile pour les tests!
  1701.   //## if (iadr[0]!=lOCAL_CHAR) {
  1702.   if (strcmp(_iadr,"file://")) {           /* non fichier */
  1703.     SOCaddr server;
  1704.     int server_size=sizeof(server);
  1705.     t_hostent* hp;    
  1706.     // effacer structure
  1707.     memset(&server, 0, sizeof(server));
  1708.  
  1709. #if HDEBUG
  1710.     printf("gethostbyname\n");
  1711. #endif
  1712.     
  1713.     // tester un Èventuel port
  1714.     if (port==-1) {
  1715.       char *a=jump_toport(iadr);
  1716. #if HTS_USEOPENSSL
  1717.       if (retour->ssl)
  1718.         port=443;
  1719.       else
  1720.         port=80;    // port par dÈfaut
  1721. #else
  1722.       port=80;    // port par dÈfaut
  1723. #endif
  1724.       if (a) {
  1725.         char iadr2[HTS_URLMAXSIZE*2];
  1726.         int i=-1;
  1727.         iadr2[0]='\0';
  1728.         sscanf(a+1,"%d",&i);
  1729.         if (i!=-1) {
  1730.           port=(unsigned short int) i;
  1731.         }
  1732.         
  1733.         // adresse vÈritable (sans :xx)
  1734.         strncatbuff(iadr2,iadr,(int) (a - iadr));
  1735.  
  1736.         // adresse sans le :xx
  1737.         hp = hts_gethostbyname(iadr2, &fullhostent_buffer);
  1738.         
  1739.       } else {
  1740.  
  1741.         // adresse normale (port par dÈfaut par la suite)
  1742.         hp = hts_gethostbyname(iadr, &fullhostent_buffer);
  1743.         
  1744.       }
  1745.       
  1746.     } else    // port dÈfini
  1747.       hp = hts_gethostbyname(iadr, &fullhostent_buffer);
  1748.  
  1749.     
  1750.     // Conversion iadr -> adresse
  1751.     // structure recevant le nom de l'hÙte, etc
  1752.     //struct     hostent     *hp;
  1753.     if (hp == NULL) {
  1754. #if DEBUG
  1755.       printf("erreur gethostbyname\n");
  1756. #endif
  1757.       if (retour)
  1758.       if (retour->msg)
  1759.         strcpybuff(retour->msg,"Unable to get server's address");
  1760.       return INVALID_SOCKET;
  1761.     }  
  1762.     // copie adresse
  1763.     SOCaddr_copyaddr(server, server_size, hp->h_addr_list[0], hp->h_length);
  1764.     // memcpy(&SOCaddr_sinaddr(server), hp->h_addr_list[0], hp->h_length);
  1765.      
  1766.     // crÈer ("attachement") une socket (point d'accËs) internet,en flot
  1767. #if HDEBUG
  1768.     printf("socket\n");
  1769. #endif
  1770. #if HTS_WIDE_DEBUG    
  1771.     DEBUG_W("socket\n");
  1772. #endif
  1773.     soc=socket(SOCaddr_sinfamily(server), SOCK_STREAM, 0);
  1774. #if HTS_WIDE_DEBUG    
  1775.     DEBUG_W("socket done\n");
  1776. #endif
  1777.     if (soc==INVALID_SOCKET) {
  1778.       if (retour)
  1779.       if (retour->msg)
  1780.         strcpybuff(retour->msg,"Unable to create a socket");
  1781.       return INVALID_SOCKET;                        // erreur crÈation socket impossible
  1782.     }
  1783.     // structure: connexion au domaine internet, port 80 (ou autre)
  1784.     SOCaddr_initport(server, port);
  1785. #if HDEBUG
  1786.     printf("==%d\n",soc);
  1787. #endif
  1788.  
  1789.     // connexion non bloquante?
  1790.     if (!waitconnect ) {
  1791.       unsigned long p=1;  // non bloquant
  1792. #if HTS_WIN
  1793.       ioctlsocket(soc,FIONBIO,&p);
  1794. #else
  1795.       ioctl(soc,FIONBIO,&p);
  1796. #endif
  1797.     }
  1798.     
  1799.     // Connexion au serveur lui mÍme
  1800. #if HDEBUG
  1801.     printf("connect\n");
  1802. #endif
  1803.     
  1804. #if HTS_WIDE_DEBUG
  1805.     DEBUG_W("connect\n");
  1806. #endif
  1807. #if HTS_WIN
  1808.     if (connect(soc, (const struct sockaddr FAR *)&server, server_size) != 0) {
  1809. #else
  1810.       if (connect(soc, (struct sockaddr *)&server, server_size) == -1) {
  1811. #endif
  1812.  
  1813.         // no - non blocking
  1814.         //deletesoc(soc);
  1815.         //soc=INVALID_SOCKET;
  1816.  
  1817.         // bloquant
  1818.         if (waitconnect) {
  1819. #if HDEBUG
  1820.           printf("unable to connect!\n");
  1821. #endif
  1822.           if (retour)
  1823.           if (retour->msg)
  1824.             strcpybuff(retour->msg,"Unable to connect to the server");
  1825.           /* Close the socket and notify the error!!! */
  1826.           deletesoc(soc);
  1827.           return INVALID_SOCKET;
  1828.         }
  1829.       }
  1830. #if HTS_WIDE_DEBUG    
  1831.       DEBUG_W("connect done\n");
  1832. #endif
  1833.       
  1834. #if HDEBUG
  1835.       printf("connexion Ètablie\n");
  1836. #endif
  1837.     
  1838.     // A partir de maintenant, on peut envoyer et recevoir des donnÈes
  1839.     // via le flot identifiÈ par soc (socket): write(soc,adr,taille) et 
  1840.     // read(soc,adr,taille)
  1841.  
  1842.   } else {    // on doit ouvrir un fichier local!
  1843.     // il sera gÈrÈ de la mÍme maniËre qu'une socket (c'est idem!)
  1844.  
  1845.     soc=LOCAL_SOCKET_ID;    // pseudo-socket locale..
  1846.     // soc sera remplacÈ lors d'un http_fopen() par un handle vÈritable!
  1847.  
  1848.   }   // teste fichier local ou http
  1849.   
  1850.   return soc;
  1851. }
  1852.  
  1853.  
  1854.  
  1855. // couper http://www.truc.fr/pub/index.html -> www.truc.fr /pub/index.html
  1856. // retour=-1 si erreur.
  1857. // si file://... alors adresse=file:// (et coupe le ?query dans ce cas)
  1858. int ident_url_absolute(char* url,char* adr,char* fil) {
  1859.   int pos=0;
  1860.   int scheme=0;
  1861.  
  1862.   // effacer adr et fil
  1863.   adr[0]=fil[0]='\0';
  1864.   
  1865. #if HDEBUG
  1866.   printf("protocol: %s\n",url);
  1867. #endif
  1868.  
  1869.   // Scheme?
  1870.   {
  1871.     char* a=url;
  1872.     while (isalpha((unsigned char)*a))
  1873.       a++;
  1874.     if (*a == ':')
  1875.       scheme=1;
  1876.   }
  1877.  
  1878.   // 1. optional scheme ":"
  1879.   if ((pos=strfield(url,"file:"))) {    // fichier local!! (pour les tests)
  1880.     //!! p+=3;
  1881.     strcpybuff(adr,"file://");
  1882.   } else if ((pos=strfield(url,"http:"))) {    // HTTP
  1883.     //!!p+=3;
  1884.   } else if ((pos=strfield(url,"ftp:"))) {    // FTP
  1885.     strcpybuff(adr,"ftp://");    // FTP!!
  1886.     //!!p+=3;
  1887. #if HTS_USEOPENSSL
  1888.   } else if (SSL_is_available && (pos=strfield(url,"https:"))) {    // HTTPS
  1889.     strcpybuff(adr,"https://");
  1890. #endif
  1891.   } else if (scheme) {
  1892.     return -1;    // erreur non reconnu
  1893.   } else
  1894.     pos=0;
  1895.  
  1896.   // 2. optional "//" authority
  1897.   if (strncmp(url+pos,"//",2)==0)
  1898.     pos+=2;
  1899.  
  1900.   // (url+pos) now points to the path (not net path)
  1901.  
  1902.   //## if (adr[0]!=lOCAL_CHAR) {    // adresse normale http
  1903.   if (!strfield(adr,"file:")) {      // PAS file://
  1904.     char *p,*q;
  1905.     p=url+pos;
  1906.  
  1907.     // p pointe sur le dÈbut de l'adresse, ex: www.truc.fr/sommaire/index.html
  1908.     q=strchr(jump_identification(p),'/');
  1909.     if (q==0) q=strchr(jump_identification(p),'?');     // http://www.foo.com?bar=1
  1910.     if (q==0) q=p+strlen(p);  // pointe sur \0
  1911.     // q pointe sur le chemin, ex: index.html?query=recherche
  1912.     
  1913.     // chemin www... trop long!!
  1914.     if ( ( ((int) (q - p)) )  > HTS_URLMAXSIZE) {
  1915.       //strcpybuff(retour.msg,"Path too long");
  1916.       return -1;    // erreur
  1917.     }
  1918.     
  1919.     // recopier adresse www..
  1920.     strncatbuff(adr,p, ((int) (q - p)) );
  1921.     // *( adr+( ((int) q) - ((int) p) ) )=0;  // faut arrÍter la fumette!
  1922.     // recopier chemin /pub/..
  1923.     if (q[0] != '/')    // page par dÈfaut (/)
  1924.       strcatbuff(fil,"/");
  1925.     strcatbuff(fil,q);
  1926.     // SECURITE:
  1927.     // simplifier url pour les ../
  1928.     fil_simplifie(fil);
  1929.   } else {    // localhost file://
  1930.     char *p;
  1931.     int i;
  1932.     char* a;
  1933.  
  1934.     p=url+pos;
  1935.     
  1936.     strcatbuff(fil,p);    // fichier local ; adr="#"
  1937.     a=strchr(fil,'?');
  1938.     if (a) 
  1939.       *a='\0';      /* couper query (inutile pour file:// lors de la requÍte) */
  1940.     // filtrer les \\ -> / pour les fichiers DOS
  1941.     for(i=0;i<(int) strlen(fil);i++)
  1942.       if (fil[i]=='\\')
  1943.         fil[i]='/';
  1944.   }
  1945.  
  1946.   // no hostname
  1947.   if (!strnotempty(adr))
  1948.     return -1;    // erreur non reconnu
  1949.  
  1950.   // nommer au besoin.. (non utilisÈ normalement)
  1951.   if (!strnotempty(fil))
  1952.     strcpybuff(fil,"default-index.html");
  1953.  
  1954.   // case insensitive pour adresse
  1955.   {
  1956.     char *a=jump_identification(adr);
  1957.     while(*a) {
  1958.       if ((*a>='A') && (*a<='Z'))
  1959.         *a+='a'-'A';       
  1960.       a++;
  1961.     }
  1962.   }
  1963.   
  1964.   return 0;
  1965. }
  1966.  
  1967. // simplification des ../
  1968. void fil_simplifie(char* f) {
  1969.   int i=0;
  1970.   int last=0;
  1971.   char* a;
  1972.  
  1973.   // Èliminer ../
  1974.   while (f[i]) {
  1975.     
  1976.     if (f[i]=='/') {
  1977.       if (f[i+1]=='.')
  1978.       if (f[i+2]=='.')      // couper dernier rÈpertoire
  1979.       if (f[i+3]=='/')      // Èviter les /tmp/..coolandlamedir/
  1980.       {    // couper dernier rÈpertoire
  1981.         char tempo[HTS_URLMAXSIZE*2];
  1982.         tempo[0]='\0';
  1983.         //
  1984.         if (!last)                /* can't go upper.. */
  1985.           strcpybuff(tempo,"/");
  1986.         else
  1987.           strncpy(tempo,f,last+1);
  1988.         tempo[last+1]='\0';
  1989.         strcatbuff(tempo,f+i+4);
  1990.         strcpybuff(f,tempo);    // remplacer
  1991.         i=-1;             // recommencer
  1992.         last=0;
  1993.       }
  1994.       
  1995.       if (i>=0)
  1996.         last=i;
  1997.       else
  1998.         last=0;
  1999.     }
  2000.     
  2001.     i++;
  2002.   }
  2003.  
  2004.   // Èliminer ./
  2005.   while ( (a=strstr(f,"./")) ) {
  2006.     char tempo[HTS_URLMAXSIZE*2];
  2007.     tempo[0]='\0';
  2008.     strcpybuff(tempo,a+2);
  2009.     strcpybuff(a,tempo);
  2010.   }
  2011.   // delete all remaining ../ (potential threat)
  2012.   while ( (a=strstr(f,"../")) ) {
  2013.     char tempo[HTS_URLMAXSIZE*2];
  2014.     tempo[0]='\0';
  2015.     strcpybuff(tempo,a+3);
  2016.     strcpybuff(a,tempo);
  2017.   }
  2018.   
  2019. }
  2020.  
  2021.  
  2022. // fermer liaison fichier ou socket
  2023. HTS_INLINE void deletehttp(htsblk* r) {
  2024. #if HTS_DEBUG_CLOSESOCK
  2025.     char info[256];
  2026.     sprintf(info,"deletehttp: (htsblk*) %d\n",r);
  2027.     DEBUG_W2(info);
  2028. #endif
  2029.   if (r->soc!=INVALID_SOCKET) {
  2030.     if (r->is_file) {
  2031.       if (r->fp)
  2032.         fclose(r->fp);
  2033.       r->fp=NULL;
  2034.     } else {
  2035.       if (r->soc!=LOCAL_SOCKET_ID)
  2036.         deletesoc_r(r);
  2037.     }
  2038.     r->soc=INVALID_SOCKET;
  2039.   }
  2040. }
  2041.  
  2042. // fermer une socket
  2043. HTS_INLINE void deletesoc(T_SOC soc) {
  2044.   if (soc!=INVALID_SOCKET) {
  2045. // J'ai plantÈ.. pas de shutdown
  2046. //#if HTS_WIDE_DEBUG    
  2047. //    DEBUG_W("shutdown\n");
  2048. //#endif
  2049. //    shutdown(soc,2);  // shutdown
  2050. //#if HTS_WIDE_DEBUG    
  2051. //    DEBUG_W("shutdown done\n");
  2052. //#endif
  2053.     // Ne pas oublier de fermer la connexion avant de partir.. (plus propre)
  2054. #if HTS_WIDE_DEBUG    
  2055.     DEBUG_W("close\n");
  2056. #endif
  2057. #if HTS_WIN
  2058.     closesocket(soc);
  2059. #else
  2060.     close(soc);
  2061. #endif
  2062. #if HTS_WIDE_DEBUG    
  2063.     DEBUG_W("close done\n");
  2064. #endif
  2065.   }
  2066. }
  2067.  
  2068. /* Will also clean other things */
  2069. HTS_INLINE void deletesoc_r(htsblk* r) {
  2070. #if HTS_USEOPENSSL
  2071.   if (SSL_is_available && r->ssl_con) {
  2072.     SSL_shutdown(r->ssl_con);
  2073.     // SSL_CTX_set_quiet_shutdown(r->ssl_con->ctx, 1);
  2074.     SSL_free(r->ssl_con);
  2075.     r->ssl_con=NULL;
  2076.   }
  2077. #endif
  2078.   deletesoc(r->soc);
  2079.   r->soc=INVALID_SOCKET;
  2080. }
  2081.  
  2082. // renvoi le nombre de secondes depuis 1970
  2083. HTS_INLINE TStamp time_local(void) {
  2084.   return ((TStamp) time(NULL));
  2085. }
  2086.  
  2087. // number of millisec since 1970
  2088. HTSEXT_API HTS_INLINE TStamp mtime_local(void) {
  2089. #ifndef HTS_DO_NOT_USE_FTIME
  2090.   struct timeb B;
  2091.   ftime( &B );
  2092.   return (TStamp) ( ((TStamp) B.time * (TStamp) 1000)
  2093.         + ((TStamp) B.millitm) );
  2094. #else
  2095.   // not precise..
  2096.   return (TStamp) ( ((TStamp) time_local() * (TStamp) 1000)
  2097.         + ((TStamp) 0) );
  2098. #endif
  2099. }
  2100.  
  2101. // convertit un nombre de secondes en temps (chaine)
  2102. void sec2str(char *st,TStamp t) {
  2103.   int j,h,m,s;
  2104.   
  2105.   j=(int) (t/(3600*24));
  2106.   t-=((TStamp) j)*(3600*24);
  2107.   h=(int) (t/(3600));
  2108.   t-=((TStamp) h)*3600;
  2109.   m=(int) (t/60);
  2110.   t-=((TStamp) m)*60;
  2111.   s=(int) t;
  2112.   
  2113.   if (j>0)
  2114.     sprintf(st,"%d days, %d hours %d minutes %d seconds",j,h,m,s);
  2115.   else if (h>0)
  2116.     sprintf(st,"%d hours %d minutes %d seconds",h,m,s);
  2117.   else if (m>0)
  2118.     sprintf(st,"%d minutes %d seconds",m,s);
  2119.   else
  2120.     sprintf(st,"%d seconds",s);
  2121. }
  2122.  
  2123. // idem, plus court (chaine)
  2124. HTSEXT_API void qsec2str(char *st,TStamp t) {
  2125.   int j,h,m,s;
  2126.   
  2127.   j=(int) (t/(3600*24));
  2128.   t-=((TStamp) j)*(3600*24);
  2129.   h=(int) (t/(3600));
  2130.   t-=((TStamp) h)*3600;
  2131.   m=(int) (t/60);
  2132.   t-=((TStamp) m)*60;
  2133.   s=(int) t;
  2134.   
  2135.   if (j>0)
  2136.     sprintf(st,"%dd,%02dh,%02dmin%02ds",j,h,m,s);
  2137.   else if (h>0)
  2138.     sprintf(st,"%dh,%02dmin%02ds",h,m,s);
  2139.   else if (m>0)
  2140.     sprintf(st,"%dmin%02ds",m,s);
  2141.   else
  2142.     sprintf(st,"%ds",s);
  2143. }
  2144.  
  2145.  
  2146. // heure actuelle, GMT, format rfc (taille buffer 256o)
  2147. void time_gmt_rfc822(char* s) {
  2148.   time_t tt;
  2149.   struct tm* A;
  2150.   tt=time(NULL);
  2151.   A=gmtime(&tt);
  2152.   if (A==NULL)
  2153.     A=localtime(&tt);
  2154.   time_rfc822(s,A);
  2155. }
  2156.  
  2157. // heure actuelle, format rfc (taille buffer 256o)
  2158. void time_local_rfc822(char* s) {
  2159.   time_t tt;
  2160.   struct tm* A;
  2161.   tt=time(NULL);
  2162.   A=localtime(&tt);
  2163.   time_rfc822_local(s,A);
  2164. }
  2165.  
  2166. /* convertir une chaine en temps */
  2167. struct tm* convert_time_rfc822(char* s) {
  2168.   struct tm* result;
  2169.   /* */
  2170.   char months[]="jan feb mar apr may jun jul aug sep oct nov dec";
  2171.   char str[256];
  2172.   char* a;
  2173.   /* */
  2174.   int result_mm=-1;
  2175.   int result_dd=-1;
  2176.   int result_n1=-1;
  2177.   int result_n2=-1;
  2178.   int result_n3=-1;
  2179.   int result_n4=-1;
  2180.   /* */
  2181.   NOSTATIC_RESERVE(result, struct tm, 1);
  2182.  
  2183.   if ((int) strlen(s) > 200)
  2184.     return NULL;
  2185.   strcpybuff(str,s);
  2186.   hts_lowcase(str);
  2187.   /* Èliminer :,- */
  2188.   while( (a=strchr(str,'-')) ) *a=' ';
  2189.   while( (a=strchr(str,':')) ) *a=' ';
  2190.   while( (a=strchr(str,',')) ) *a=' ';
  2191.   /* tokeniser */
  2192.   a=str;
  2193.   while(*a) {
  2194.     char *first,*last;
  2195.     char tok[256];
  2196.     /* dÈcouper mot */
  2197.     while(*a==' ') a++;   /* sauter espaces */
  2198.     first=a;
  2199.     while((*a) && (*a!=' ')) a++;
  2200.     last=a;
  2201.     tok[0]='\0';
  2202.     if (first!=last) {
  2203.       char* pos;
  2204.       strncatbuff(tok,first,(int) (last - first));
  2205.       /* analyser */
  2206.       if ( (pos=strstr(months,tok)) ) {               /* month always in letters */
  2207.         result_mm=((int) (pos - months))/4;
  2208.       } else {
  2209.         int number;
  2210.         if (sscanf(tok,"%d",&number) == 1) {      /* number token */
  2211.           if (result_dd<0)                        /* day always first number */
  2212.             result_dd=number;
  2213.           else if (result_n1<0)
  2214.             result_n1=number;
  2215.           else if (result_n2<0)
  2216.             result_n2=number;
  2217.           else if (result_n3<0)
  2218.             result_n3=number;
  2219.           else if (result_n4<0)
  2220.             result_n4=number;
  2221.         }   /* sinon, bruit de fond(+1GMT for exampel) */
  2222.       }
  2223.     }
  2224.   }
  2225.   if ((result_n1>=0) && (result_mm>=0) && (result_dd>=0) && (result_n2>=0) && (result_n3>=0) && (result_n4>=0)) {
  2226.     if (result_n4>=1000) {               /* Sun Nov  6 08:49:37 1994 */
  2227.       result->tm_year=result_n4-1900;
  2228.       result->tm_hour=result_n1;
  2229.       result->tm_min=result_n2;
  2230.       result->tm_sec=max(result_n3,0);
  2231.     } else {                            /* Sun, 06 Nov 1994 08:49:37 GMT or Sunday, 06-Nov-94 08:49:37 GMT */
  2232.       result->tm_hour=result_n2;
  2233.       result->tm_min=result_n3;
  2234.       result->tm_sec=max(result_n4,0);
  2235.       if (result_n1<=50)                /* 00 means 2000 */
  2236.         result->tm_year=result_n1+100;
  2237.       else if (result_n1<1000)          /* 99 means 1999 */
  2238.         result->tm_year=result_n1;
  2239.       else                              /* 2000 */
  2240.         result->tm_year=result_n1-1900;
  2241.     }
  2242.     result->tm_isdst=0;        /* assume GMT */
  2243.     result->tm_yday=-1;        /* don't know */
  2244.     result->tm_wday=-1;        /* don't know */
  2245.     result->tm_mon=result_mm;
  2246.     result->tm_mday=result_dd;
  2247.     return result;
  2248.   }
  2249.   return NULL;
  2250. }
  2251.  
  2252. /* sets file time. -1 if error */
  2253. int set_filetime(char* file,struct tm* tm_time) {
  2254.   struct utimbuf tim;
  2255. #ifndef HTS_DO_NOT_USE_FTIME
  2256.   struct timeb B;
  2257.   B.timezone=0;
  2258.   ftime( &B );
  2259.   tim.actime=tim.modtime=mktime(tm_time) - B.timezone*60; 
  2260. #else
  2261.   // bogus time (GMT/local)..
  2262.   tim.actime=tim.modtime=mktime(tm_time); 
  2263. #endif
  2264.   return utime(file,&tim);
  2265. }
  2266.  
  2267. /* sets file time from RFC822 date+time, -1 if error*/
  2268. int set_filetime_rfc822(char* file,char* date) {
  2269.   struct tm* tm_s=convert_time_rfc822(date);
  2270.   if (tm_s) {
  2271.     return set_filetime(file,tm_s);
  2272.   } else return -1;
  2273. }
  2274.  
  2275.  
  2276. // heure au format rfc (taille buffer 256o)
  2277. HTS_INLINE void time_rfc822(char* s,struct tm * A) {
  2278.   strftime(s,256,"%a, %d %b %Y %H:%M:%S GMT",A);
  2279. }
  2280.  
  2281. // heure locale au format rfc (taille buffer 256o)
  2282. HTS_INLINE void time_rfc822_local(char* s,struct tm * A) {
  2283.   strftime(s,256,"%a, %d %b %Y %H:%M:%S",A);
  2284. }
  2285.  
  2286. // conversion en b,Kb,Mb
  2287. HTSEXT_API char* int2bytes(LLint n) {
  2288.   char** a=int2bytes2(n);
  2289.   char* buff;
  2290.   NOSTATIC_RESERVE(buff, char, 256);
  2291.  
  2292.   strcpybuff(buff,a[0]);
  2293.   strcatbuff(buff,a[1]);
  2294.   return concat(buff,"");
  2295. }
  2296.  
  2297. // conversion en b/s,Kb/s,Mb/s
  2298. HTSEXT_API char* int2bytessec(long int n) {
  2299.   char* buff;
  2300.   char** a=int2bytes2(n);
  2301.   NOSTATIC_RESERVE(buff, char, 256);
  2302.  
  2303.   strcpybuff(buff,a[0]);
  2304.   strcatbuff(buff,a[1]);
  2305.   return concat(buff,"/s");
  2306. }
  2307. HTSEXT_API char* int2char(int n) {
  2308.   char* buffer;
  2309.   NOSTATIC_RESERVE(buffer, char, 32);
  2310.   sprintf(buffer,"%d",n);
  2311.   return concat(buffer,"");
  2312. }
  2313.  
  2314. // conversion en b,Kb,Mb, nombre et type sÈparÈs
  2315. // limite: 2.10^9.10^6B
  2316.  
  2317. /* See http://physics.nist.gov/cuu/Units/binary.html */
  2318. #define ToLLint(a) ((LLint)(a))
  2319. #define ToLLintKiB (ToLLint(1024))
  2320. #define ToLLintMiB (ToLLintKiB*ToLLintKiB)
  2321. #ifdef HTS_LONGLONG
  2322. #define ToLLintGiB (ToLLintKiB*ToLLintKiB*ToLLintKiB)
  2323. #define ToLLintTiB (ToLLintKiB*ToLLintKiB*ToLLintKiB*ToLLintKiB)
  2324. #define ToLLintPiB (ToLLintKiB*ToLLintKiB*ToLLintKiB*ToLLintKiB*ToLLintKiB)
  2325. #endif
  2326. typedef struct {
  2327.   char buff1[256];
  2328.   char buff2[32];
  2329.   char* buffadr[2];
  2330. } strc_int2bytes2;
  2331. HTSEXT_API char** int2bytes2(LLint n) {
  2332.   strc_int2bytes2* strc;
  2333.   NOSTATIC_RESERVE(strc, strc_int2bytes2, 1);
  2334.  
  2335.   if (n < ToLLintKiB) {
  2336.     sprintf(strc->buff1,"%d",(int)(LLint)n);
  2337.     strcpybuff(strc->buff2,"B");
  2338.   } else if (n < ToLLintMiB) {
  2339.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/ToLLintKiB)),(int)((LLint)((n%ToLLintKiB)*100)/ToLLintKiB));
  2340.     strcpybuff(strc->buff2,"KiB");
  2341.   }
  2342. #ifdef HTS_LONGLONG
  2343.   else if (n < ToLLintGiB) {
  2344.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/(ToLLintMiB))),(int)((LLint)(((n%(ToLLintMiB))*100)/(ToLLintMiB))));
  2345.     strcpybuff(strc->buff2,"MiB");
  2346.   } else if (n < ToLLintTiB) {
  2347.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/(ToLLintGiB))),(int)((LLint)(((n%(ToLLintGiB))*100)/(ToLLintGiB))));
  2348.     strcpybuff(strc->buff2,"GiB");
  2349.   } else if (n < ToLLintPiB) {
  2350.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/(ToLLintTiB))),(int)((LLint)(((n%(ToLLintTiB))*100)/(ToLLintTiB))));
  2351.     strcpybuff(strc->buff2,"TiB");
  2352.   } else {
  2353.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/(ToLLintPiB))),(int)((LLint)(((n%(ToLLintPiB))*100)/(ToLLintPiB))));
  2354.     strcpybuff(strc->buff2,"PiB");
  2355.   }
  2356. #else
  2357.   else {
  2358.     sprintf(strc->buff1,"%d,%02d",(int)((LLint)(n/(ToLLintMiB))),(int)((LLint)(((n%(ToLLintMiB))*100)/(ToLLintMiB))));
  2359.     strcpybuff(strc->buff2,"MiB");
  2360.   }
  2361. #endif
  2362.   strc->buffadr[0]=strc->buff1;
  2363.   strc->buffadr[1]=strc->buff2;
  2364.   return strc->buffadr;
  2365. }
  2366.  
  2367. #if HTS_WIN
  2368. #else
  2369. // ignore sigpipe?
  2370. int sig_ignore_flag( int setflag ) {     // flag ignore
  2371.   static int flag=0;   /* YES, this one is true static */
  2372.   if (setflag>=0)
  2373.     flag=setflag;
  2374.   return flag;
  2375. }
  2376. #endif
  2377.  
  2378. // envoi de texte (en tÍtes gÈnÈralement) sur la socket soc
  2379. HTS_INLINE int sendc(htsblk* r, char* s) {
  2380.   int n;
  2381.  
  2382. #if HTS_WIN
  2383. #else
  2384.   sig_ignore_flag(1);
  2385. #endif
  2386. #if HDEBUG
  2387.   write(0,s,strlen(s));
  2388. #endif
  2389.  
  2390. #if HTS_USEOPENSSL
  2391.   if (SSL_is_available && r->ssl) {
  2392.     n = SSL_write(r->ssl_con, s, strlen(s));
  2393.   } else
  2394. #endif
  2395.     n = send(r->soc,s,strlen(s),0);
  2396.  
  2397. #if HTS_WIN
  2398. #else
  2399.   sig_ignore_flag(0);
  2400. #endif
  2401.  
  2402.   return n;
  2403. }
  2404.  
  2405.  
  2406. // Remplace read
  2407. void finput(int fd,char* s,int max) {
  2408.   char c;
  2409.   int j=0;
  2410.   do {
  2411.     //c=fgetc(fp);
  2412.     if (read(fd,&c,1)<=0) {
  2413.       c=0;
  2414.     }
  2415.     if (c!=0) {
  2416.       switch(c) {
  2417.       case 10: c=0; break;
  2418.       case 13: break;  // sauter ces caractËres
  2419.       default: s[j++]=c; break;
  2420.       }
  2421.     }
  2422.   }  while((c!=0) && (j<max-1));
  2423.   s[j++]='\0';
  2424. } 
  2425.  
  2426. // Like linput, but in memory (optimized)
  2427. int binput(char* buff,char* s,int max) {
  2428.   char* end;
  2429.   int count;
  2430.  
  2431.   // clear buffer
  2432.   s[0]='\0';
  2433.   // end of buffer?
  2434.   if ( *buff == '\0')
  2435.     return 1;
  2436.   // find ending \n
  2437.   end=strchr(buff,'\n');
  2438.   // ..or end of buffer
  2439.   if (!end)
  2440.     end=buff+strlen(buff);
  2441.   // then count number of bytes, maximum=max
  2442.   count=min(max,end-buff);
  2443.   // and strip annoying ending cr
  2444.   while( (count>0) && (buff[count] == '\r'))
  2445.     count--;
  2446.   // copy
  2447.   if (count > 0) {
  2448.     strncatbuff(s, buff, count);
  2449.   }
  2450.   // and terminate with a null char
  2451.   s[count]='\0';
  2452.   // then return the supplemental jump offset
  2453.   return (end-buff)+1;
  2454. } 
  2455.  
  2456. // Lecture d'une ligne (peut Ítre unicode ‡ priori)
  2457. int linput(FILE* fp,char* s,int max) {
  2458.   int c;
  2459.   int j=0;
  2460.   do {
  2461.     c=fgetc(fp);
  2462.     if (c!=EOF) {
  2463.       switch(c) {
  2464.         case 13: break;  // sauter CR
  2465.         case 10: c=-1; break;
  2466.         case 9: case 12: break;  // sauter ces caractËres
  2467.         default: s[j++]=(char) c; break;
  2468.       }
  2469.     }
  2470.   }  while((c!=-1) && (c!=EOF) && (j<(max-1)));
  2471.   s[j]='\0';
  2472.   return j;
  2473. }
  2474. int linput_trim(FILE* fp,char* s,int max) {
  2475.   int rlen=0;
  2476.   char* ls=(char*) malloct(max+2);
  2477.   s[0]='\0';
  2478.   if (ls) {
  2479.     char* a;
  2480.     // lire ligne
  2481.     rlen=linput(fp,ls,max);
  2482.     if (rlen) {
  2483.       // sauter espaces et tabs en fin
  2484.       while( (rlen>0) && ((ls[max(rlen-1,0)]==' ') || (ls[max(rlen-1,0)]=='\t')) )
  2485.         ls[--rlen]='\0';
  2486.       // sauter espaces en dÈbut
  2487.       a=ls;
  2488.       while((rlen>0) && ((*a==' ') || (*a=='\t'))) {
  2489.         a++;
  2490.         rlen--;
  2491.       }
  2492.       if (rlen>0) {
  2493.         memcpy(s,a,rlen);      // can copy \0 chars
  2494.         s[rlen]='\0';
  2495.       }
  2496.     }
  2497.     //
  2498.     freet(ls);
  2499.   }
  2500.   return rlen;
  2501. }
  2502. int linput_cpp(FILE* fp,char* s,int max) {
  2503.   int rlen=0;
  2504.   s[0]='\0';
  2505.   do {
  2506.     int ret;
  2507.     if (rlen>0)
  2508.     if (s[rlen-1]=='\\')
  2509.       s[--rlen]='\0';      // couper \ final
  2510.     // lire ligne
  2511.     ret=linput_trim(fp,s+rlen,max-rlen);
  2512.     if (ret>0)
  2513.       rlen+=ret;
  2514.   } while((s[max(rlen-1,0)]=='\\') && (rlen<max));
  2515.   return rlen;
  2516. }
  2517.  
  2518. // idem avec les car spÈciaux
  2519. void rawlinput(FILE* fp,char* s,int max) {
  2520.   int c;
  2521.   int j=0;
  2522.   do {
  2523.     c=fgetc(fp);
  2524.     if (c!=EOF) {
  2525.       switch(c) {
  2526.         case 13: break;  // sauter CR
  2527.         case 10: c=-1; break;
  2528.         default: s[j++]=(char) c; break;
  2529.       }
  2530.     }
  2531.   }  while((c!=-1) && (c!=EOF) && (j<(max-1)));
  2532.   s[j++]='\0';
  2533. }
  2534.  
  2535.  
  2536. // compare le dÈbut de f avec s et retourne la position de la fin
  2537. // 'A=a' (case insensitive)
  2538. int strfield(const char* f,const char* s) {
  2539.   int r=0;
  2540.   while (streql(*f,*s) && ((*f)!=0) && ((*s)!=0)) { f++; s++; r++; }
  2541.   if (*s==0)
  2542.     return r;
  2543.   else
  2544.     return 0;
  2545. }
  2546.  
  2547. //cherche chaine, case insensitive
  2548. char* strstrcase(char *s,char *o) {
  2549.   while((*s) && (strfield(s,o)==0)) s++;
  2550.   if (*s=='\0') return NULL;
  2551.   return s;  
  2552. }
  2553.  
  2554.  
  2555. // Unicode detector
  2556. // See http://www.unicode.org/unicode/reports/tr28/
  2557. // (sect Table 3.1B. Legal UTF-8 Byte Sequences)
  2558. typedef struct {
  2559.   unsigned int pos;
  2560.   unsigned char data[4];
  2561. } t_auto_seq;
  2562.  
  2563. // char between a and b
  2564. #define CHAR_BETWEEN(c, a, b)       ( (c) >= 0x##a ) && ( (c) <= 0x##b )
  2565. // sequence start
  2566. #define SEQBEG                      ( inseq == 0 )
  2567. // in this block
  2568. #define BLK(n,a, b)                 ( (seq.pos >= n) && ((err = CHAR_BETWEEN(seq.data[n], a, b))) )
  2569. #define ELT(n,a)                    BLK(n,a,a)
  2570. // end
  2571. #define SEQEND                      ((ok = 1))
  2572. // sequence started, character will fail if error
  2573. #define IN_SEQ                      ( (inseq = 1) )
  2574. // decoding error
  2575. #define BAD_SEQ                     ( (ok == 0) && (inseq != 0) && (!err) )
  2576. // no sequence started
  2577. #define NO_SEQ                      ( inseq == 0 )
  2578.  
  2579. // is this block an UTF unicode textfile?
  2580. // 0 : no
  2581. // 1 : yes
  2582. // -1: don't know
  2583. int is_unicode_utf8(unsigned char* buffer, unsigned int size) {
  2584.   t_auto_seq seq;
  2585.   unsigned int i;
  2586.   int is_utf=-1;
  2587.  
  2588.   seq.pos=0;
  2589.   for(i=0 ; i < size ; i++) {
  2590.     unsigned int ok=0;
  2591.     unsigned int inseq=0;
  2592.     unsigned int err=0;
  2593.  
  2594.     seq.data[seq.pos]=buffer[i];
  2595.     /**/ if ( SEQBEG && BLK(0,00,7F) && IN_SEQ && SEQEND                                                 ) { }
  2596.     else if ( SEQBEG && BLK(0,C2,DF) && IN_SEQ && BLK(1,80,BF) && SEQEND                                 ) { }
  2597.     else if ( SEQBEG && ELT(0,E0   ) && IN_SEQ && BLK(1,A0,BF) && BLK(2,80,BF) && SEQEND                 ) { }
  2598.     else if ( SEQBEG && BLK(0,E1,EC) && IN_SEQ && BLK(1,80,BF) && BLK(2,80,BF) && SEQEND                 ) { }
  2599.     else if ( SEQBEG && ELT(0,ED   ) && IN_SEQ && BLK(1,80,9F) && BLK(2,80,BF) && SEQEND                 ) { }
  2600.     else if ( SEQBEG && BLK(0,EE,EF) && IN_SEQ && BLK(1,80,BF) && BLK(2,80,BF) && SEQEND                 ) { }
  2601.     else if ( SEQBEG && ELT(0,F0   ) && IN_SEQ && BLK(1,90,BF) && BLK(2,80,BF) && BLK(3,80,BF) && SEQEND ) { }
  2602.     else if ( SEQBEG && BLK(0,F1,F3) && IN_SEQ && BLK(1,80,BF) && BLK(2,80,BF) && BLK(3,80,BF) && SEQEND ) { }
  2603.     else if ( SEQBEG && ELT(0,F4   ) && IN_SEQ && BLK(1,80,8F) && BLK(2,80,BF) && BLK(3,80,BF) && SEQEND ) { }
  2604.     else if ( NO_SEQ ) {    // bad, unknown
  2605.       return 0;
  2606.     }
  2607.     /* */
  2608.     
  2609.     /* Error */
  2610.     if ( BAD_SEQ ) {
  2611.       return 0;
  2612.     }
  2613.  
  2614.     /* unicode character */
  2615.     if (seq.pos > 0)
  2616.       is_utf=1;
  2617.  
  2618.     /* Next */
  2619.     if (ok)
  2620.       seq.pos=0;
  2621.     else
  2622.       seq.pos++;
  2623.  
  2624.     /* Internal error */
  2625.     if (seq.pos >= 4)
  2626.       return 0;
  2627.  
  2628.   }
  2629.  
  2630.   return is_utf;
  2631. }
  2632.  
  2633. void map_characters(unsigned char* buffer, unsigned int size, unsigned int* map) {
  2634.   unsigned int i;
  2635.   memset(map, 0, sizeof(unsigned int) * 256);
  2636.   for(i = 0 ; i < size ; i++) {
  2637.     map[buffer[i]]++;
  2638.   }
  2639. }
  2640.  
  2641.  
  2642. // le fichier est-il un fichier html?
  2643. //  0 : non
  2644. //  1 : oui
  2645. // -1 : on sait pas
  2646. // -2 : on sait pas, pas d'extension
  2647. int ishtml(char* fil) {
  2648.   char *a;
  2649.  
  2650.   // patch pour les truc.html?Choix=toto
  2651.   if ( (a=strchr(fil,'?')) )  // paramËtres?
  2652.     a--;  // pointer juste avant le ?
  2653.   else
  2654.     a=fil+strlen(fil)-1;  // pointer sur le dernier caractËre
  2655.  
  2656.   if (*a=='/') return -1;    // rÈpertoire, on sait pas!!
  2657.   //if (*a=='/') return 1;    // ok rÈpertoire, html
  2658.  
  2659.   while ( (*a!='.') && (*a!='/')  && ( a > fil)) a--;
  2660.   if (*a=='.') {  // a une extension
  2661.     char fil_noquery[HTS_URLMAXSIZE*2];
  2662.     fil_noquery[0]='\0';
  2663.     a++;  // pointer sur extension
  2664.     strncatbuff(fil_noquery,a,HTS_URLMAXSIZE);
  2665.     a=strchr(fil_noquery,'?');
  2666.     if (a)
  2667.       *a='\0';
  2668.     return ishtml_ext(fil_noquery);     // retour
  2669.   } else return -2;   // indÈterminÈ, par exemple /truc
  2670. }
  2671.  
  2672. // idem, mais pour uniquement l'extension
  2673. int ishtml_ext(char* a) {
  2674.   int html=0;  
  2675.   //
  2676.   if (strfield2(a,"html"))       html = 1;
  2677.   else if (strfield2(a,"htm"))   html = 1;
  2678.   else if (strfield2(a,"shtml")) html = 1;
  2679.   else if (strfield2(a,"phtml")) html = 1;
  2680.   else if (strfield2(a,"htmlx")) html = 1;
  2681.   else if (strfield2(a,"shtm"))  html = 1;
  2682.   else if (strfield2(a,"phtm"))  html = 1;
  2683.   else if (strfield2(a,"htmx"))  html = 1;
  2684.   //
  2685.   // insuccËs..
  2686.   else {
  2687.     switch(is_knowntype(a)) {
  2688.     case 1:
  2689.       html = 0;     // connu, non html
  2690.       break;
  2691.     case 2:
  2692.       html = 1;     // connu, html
  2693.       break;
  2694.     default:
  2695.       html = -1;    // inconnu..
  2696.       break;
  2697.     }
  2698.   }
  2699.   return html;  
  2700. }
  2701.  
  2702. // error (404,500..)
  2703. HTS_INLINE int ishttperror(int err) {
  2704.   switch (err/100) {
  2705.     case 4: case 5: return 1;
  2706.       break;
  2707.   }
  2708.   return 0;
  2709. }
  2710.  
  2711.  
  2712. // retourne le pointeur ou le pointeur + offset si il existe dans la chaine un @ signifiant 
  2713. // une identification
  2714. HTSEXT_API char* jump_identification(char* source) {
  2715.   char *a,*trytofind;
  2716.   // rechercher dernier @ (car parfois email transmise dans adresse!)
  2717.   // mais sauter ftp:// Èventuel
  2718.   a = jump_protocol(source);
  2719.   trytofind = strrchr_limit(a, '@', strchr(a,'/'));
  2720.   return (trytofind != NULL)?trytofind:a;
  2721. }
  2722.  
  2723. // find port (:80) or NULL if not found
  2724. // can handle IPV6 addresses
  2725. HTSEXT_API char* jump_toport(char* source) {
  2726.   char *a,*trytofind;
  2727.   a = jump_identification(source);
  2728.   trytofind = strrchr_limit(a, ']', strchr(source, '/'));    // find last ] (http://[3ffe:b80:1234::1]:80/foo.html)
  2729.   a = strchr( (trytofind)?trytofind:a, ':');
  2730.   return a;
  2731. }
  2732.  
  2733. // strrchr, but not too far
  2734. char* strrchr_limit(char* s, char c, char* limit) {
  2735.   if (limit == NULL) {
  2736.     char* p = strrchr(s, c);
  2737.     return p?(p+1):NULL;
  2738.   } else {
  2739.     char *a=NULL, *p;
  2740.     for(;;) {
  2741.       p=strchr((a)?a:s, c);
  2742.       if ((p >= limit) || (p == NULL))
  2743.         return a;
  2744.       a=p+1;
  2745.     }
  2746.   }
  2747. }
  2748.  
  2749. // retourner adr sans ftp://
  2750. HTS_INLINE char* jump_protocol(char* source) {
  2751.   int p;
  2752.   // scheme
  2753.   // "Comparisons of scheme names MUST be case-insensitive" (RFC2616)
  2754.   if ((p=strfield(source,"http:")))
  2755.     source+=p;
  2756.   else if ((p=strfield(source,"ftp:")))
  2757.     source+=p;
  2758.   else if ((p=strfield(source,"https:")))
  2759.     source+=p;
  2760.   else if ((p=strfield(source,"file:")))
  2761.     source+=p;
  2762.   // net_path
  2763.   if (strncmp(source,"//",2)==0)
  2764.     source+=2;
  2765.   return source;
  2766. }
  2767.  
  2768. // codage base 64 a vers b
  2769. void code64(char* a,char* b) {
  2770.   int i1=0,i2=0,i3=0,i4=0;
  2771.   unsigned long store;
  2772.   int n;
  2773.   const char _hts_base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  2774.   b[0]='\0';
  2775.   while(*a) {  
  2776.     // 24 bits
  2777.     n=1; store=0; store |= ((*a++) & 0xff);
  2778.     if (*a) { n=2; store <<= 8; store |= ((*a++) & 0xff); }
  2779.     if (*a) { n=3; store <<= 8; store |= ((*a++) & 0xff); }
  2780.     if (n==3) {
  2781.       i4=store & 63;
  2782.       i3=(store>>6) & 63;
  2783.       i2=(store>>12) & 63;
  2784.       i1=(store>>18) & 63;
  2785.     } else if (n==2) {
  2786.       store<<=2;    
  2787.       i3=store & 63;
  2788.       i2=(store>>6) & 63;
  2789.       i1=(store>>12) & 63;
  2790.     } else {
  2791.       store<<=4;
  2792.       i2=store & 63;
  2793.       i1=(store>>6) & 63;
  2794.     }
  2795.     
  2796.     *b++ = _hts_base64[i1];
  2797.     *b++ = _hts_base64[i2];
  2798.     if (n>=2)
  2799.       *b++ = _hts_base64[i3];
  2800.     else
  2801.       *b++ = '=';
  2802.     if (n>=3)
  2803.       *b++ = _hts_base64[i4];
  2804.     else
  2805.       *b++ = '=';
  2806.   }
  2807.   *b++='\0';
  2808. }
  2809.  
  2810. // remplacer " par " etc..
  2811. // buffer MAX 1Ko
  2812. #define strcmpbeg(a, b) strncmp(a, b, strlen(b))
  2813. HTSEXT_API void unescape_amp(char* s) {
  2814.   while(*s) {
  2815.     if (*s=='&') {
  2816.       char* end=strchr(s,';');
  2817.       if ( end && (((int) (end - s)) <= 8) ) {
  2818.         unsigned char c=0;
  2819.         
  2820.         // http://www.w3.org/TR/xhtml-modularization/dtd_module_defs.html
  2821.         if (strcmpbeg(s, "&#") == 0) {
  2822.           int num=0;
  2823.           if ( (s[2] == 'x') || (s[2] == 'X')) {
  2824.             if (sscanf(s+3, "%x", &num) == 1) {
  2825.               c=(unsigned char)num;
  2826.             }
  2827.           } else {
  2828.             if (sscanf(s+2, "%d", &num) == 1) {
  2829.               c=(unsigned char)num;
  2830.             }
  2831.           }
  2832.         } else if (strcmpbeg(s, " ")==0)
  2833.           c=32; // hack - c=160;
  2834.         else if (strcmpbeg(s, "¡")==0)
  2835.           c=161;
  2836.         else if (strcmpbeg(s, "¢")==0)
  2837.           c=162;
  2838.         else if (strcmpbeg(s, "£")==0)
  2839.           c=163;
  2840.         else if (strcmpbeg(s, "¤")==0)
  2841.           c=164;
  2842.         else if (strcmpbeg(s, "¥")==0)
  2843.           c=165;
  2844.         else if (strcmpbeg(s, "¦")==0)
  2845.           c=166;
  2846.         else if (strcmpbeg(s, "§")==0)
  2847.           c=167;
  2848.         else if (strcmpbeg(s, "¨")==0)
  2849.           c=168;
  2850.         else if (strcmpbeg(s, "©")==0)
  2851.           c=169;
  2852.         else if (strcmpbeg(s, "ª")==0)
  2853.           c=170;
  2854.         //else if (strcmpbeg(s, "«")==0)
  2855.         //  c=171;
  2856.         else if (strcmpbeg(s, "¬")==0)
  2857.           c=172;
  2858.         //else if (strcmpbeg(s, "­")==0)
  2859.         //  c=173;
  2860.         else if (strcmpbeg(s, "®")==0)
  2861.           c=174;
  2862.         else if (strcmpbeg(s, "¯")==0)
  2863.           c=175;
  2864.         else if (strcmpbeg(s, "°")==0)
  2865.           c=176;
  2866.         else if (strcmpbeg(s, "±")==0)
  2867.           c=177;
  2868.         else if (strcmpbeg(s, "²")==0)
  2869.           c=178;
  2870.         else if (strcmpbeg(s, "³")==0)
  2871.           c=179;
  2872.         else if (strcmpbeg(s, "´")==0)
  2873.           c=180;
  2874.         else if (strcmpbeg(s, "µ")==0)
  2875.           c=181;
  2876.         else if (strcmpbeg(s, "¶")==0)
  2877.           c=182;
  2878.         else if (strcmpbeg(s, "·")==0)
  2879.           c=183;
  2880.         else if (strcmpbeg(s, "¸")==0)
  2881.           c=184;
  2882.         else if (strcmpbeg(s, "¹")==0)
  2883.           c=185;
  2884.         else if (strcmpbeg(s, "º")==0)
  2885.           c=186;
  2886.         //else if (strcmpbeg(s, "»")==0)
  2887.         //  c=187;
  2888.         else if (strcmpbeg(s, "¼")==0)
  2889.           c=188;
  2890.         else if (strcmpbeg(s, "½")==0)
  2891.           c=189;
  2892.         else if (strcmpbeg(s, "¾")==0)
  2893.           c=190;
  2894.         else if (strcmpbeg(s, "¿")==0)
  2895.           c=191;
  2896.         else if (strcmpbeg(s, "À")==0)
  2897.           c=192;
  2898.         else if (strcmpbeg(s, "Á")==0)
  2899.           c=193;
  2900.         else if (strcmpbeg(s, "Â")==0)
  2901.           c=194;
  2902.         else if (strcmpbeg(s, "Ã")==0)
  2903.           c=195;
  2904.         else if (strcmpbeg(s, "Ä")==0)
  2905.           c=196;
  2906.         else if (strcmpbeg(s, "Å")==0)
  2907.           c=197;
  2908.         else if (strcmpbeg(s, "Æ")==0)
  2909.           c=198;
  2910.         else if (strcmpbeg(s, "Ç")==0)
  2911.           c=199;
  2912.         else if (strcmpbeg(s, "È")==0)
  2913.           c=200;
  2914.         else if (strcmpbeg(s, "É")==0)
  2915.           c=201;
  2916.         else if (strcmpbeg(s, "Ê")==0)
  2917.           c=202;
  2918.         else if (strcmpbeg(s, "Ë")==0)
  2919.           c=203;
  2920.         else if (strcmpbeg(s, "Ì")==0)
  2921.           c=204;
  2922.         else if (strcmpbeg(s, "Í")==0)
  2923.           c=205;
  2924.         else if (strcmpbeg(s, "Î")==0)
  2925.           c=206;
  2926.         else if (strcmpbeg(s, "Ï")==0)
  2927.           c=207;
  2928.         else if (strcmpbeg(s, "Ð")==0)
  2929.           c=208;
  2930.         else if (strcmpbeg(s, "Ñ")==0)
  2931.           c=209;
  2932.         else if (strcmpbeg(s, "Ò")==0)
  2933.           c=210;
  2934.         else if (strcmpbeg(s, "Ó")==0)
  2935.           c=211;
  2936.         else if (strcmpbeg(s, "Ô")==0)
  2937.           c=212;
  2938.         else if (strcmpbeg(s, "Õ")==0)
  2939.           c=213;
  2940.         else if (strcmpbeg(s, "Ö")==0)
  2941.           c=214;
  2942.         else if (strcmpbeg(s, "×")==0)
  2943.           c=215;
  2944.         else if (strcmpbeg(s, "Ø")==0)
  2945.           c=216;
  2946.         else if (strcmpbeg(s, "Ù")==0)
  2947.           c=217;
  2948.         else if (strcmpbeg(s, "Ú")==0)
  2949.           c=218;
  2950.         else if (strcmpbeg(s, "Û")==0)
  2951.           c=219;
  2952.         else if (strcmpbeg(s, "Ü")==0)
  2953.           c=220;
  2954.         else if (strcmpbeg(s, "Ý")==0)
  2955.           c=221;
  2956.         else if (strcmpbeg(s, "Þ")==0)
  2957.           c=222;
  2958.         else if (strcmpbeg(s, "ß")==0)
  2959.           c=223;
  2960.         else if (strcmpbeg(s, "à")==0)
  2961.           c=224;
  2962.         else if (strcmpbeg(s, "á")==0)
  2963.           c=225;
  2964.         else if (strcmpbeg(s, "â")==0)
  2965.           c=226;
  2966.         else if (strcmpbeg(s, "ã")==0)
  2967.           c=227;
  2968.         else if (strcmpbeg(s, "ä")==0)
  2969.           c=228;
  2970.         else if (strcmpbeg(s, "å")==0)
  2971.           c=229;
  2972.         else if (strcmpbeg(s, "æ")==0)
  2973.           c=230;
  2974.         else if (strcmpbeg(s, "ç")==0)
  2975.           c=231;
  2976.         else if (strcmpbeg(s, "è")==0)
  2977.           c=232;
  2978.         else if (strcmpbeg(s, "é")==0)
  2979.           c=233;
  2980.         else if (strcmpbeg(s, "ê")==0)
  2981.           c=234;
  2982.         else if (strcmpbeg(s, "ë")==0)
  2983.           c=235;
  2984.         else if (strcmpbeg(s, "ì")==0)
  2985.           c=236;
  2986.         else if (strcmpbeg(s, "í")==0)
  2987.           c=237;
  2988.         else if (strcmpbeg(s, "î")==0)
  2989.           c=238;
  2990.         else if (strcmpbeg(s, "ï")==0)
  2991.           c=239;
  2992.         else if (strcmpbeg(s, "ð")==0)
  2993.           c=240;
  2994.         else if (strcmpbeg(s, "ñ")==0)
  2995.           c=241;
  2996.         else if (strcmpbeg(s, "ò")==0)
  2997.           c=242;
  2998.         else if (strcmpbeg(s, "ó")==0)
  2999.           c=243;
  3000.         else if (strcmpbeg(s, "ô")==0)
  3001.           c=244;
  3002.         else if (strcmpbeg(s, "õ")==0)
  3003.           c=245;
  3004.         else if (strcmpbeg(s, "ö")==0)
  3005.           c=246;
  3006.         else if (strcmpbeg(s, "÷")==0)
  3007.           c=247;
  3008.         else if (strcmpbeg(s, "ø")==0)
  3009.           c=248;
  3010.         else if (strcmpbeg(s, "ù")==0)
  3011.           c=249;
  3012.         else if (strcmpbeg(s, "ú")==0)
  3013.           c=250;
  3014.         else if (strcmpbeg(s, "û")==0)
  3015.           c=251;
  3016.         else if (strcmpbeg(s, "ü")==0)
  3017.           c=252;
  3018.         else if (strcmpbeg(s, "ý")==0)
  3019.           c=253;
  3020.         else if (strcmpbeg(s, "þ")==0)
  3021.           c=254;
  3022.         else if (strcmpbeg(s, "ÿ")==0)
  3023.           c=255;
  3024.         //        
  3025.         else if (strcmpbeg(s,"&")==0)
  3026.           c='&';
  3027.         else if (strcmpbeg(s,">")==0)
  3028.           c='>';
  3029.         else if (strcmpbeg(s,"«")==0)
  3030.           c='\"';
  3031.         else if (strcmpbeg(s,"<")==0)
  3032.           c='<';
  3033.         else if (strcmpbeg(s," ")==0)
  3034.           c=' ';
  3035.         else if (strcmpbeg(s,""")==0)
  3036.           c='\"';
  3037.         else if (strcmpbeg(s,"»")==0)
  3038.           c='\"';
  3039.         else if (strcmpbeg(s,"­")==0)
  3040.           c='-';
  3041.         else if (strcmpbeg(s,"˜")==0)
  3042.           c='~';
  3043.         // remplacer?
  3044.         if (c) {
  3045.           char buff[HTS_URLMAXSIZE*2];
  3046.           buff[0]=(char) c;
  3047.           strcpybuff(buff+1,end+1);
  3048.           strcpybuff(s,buff);
  3049.         }
  3050.       }
  3051.     }
  3052.     s++;
  3053.   }
  3054. }
  3055.  
  3056. // remplacer %20 par ' ', | par : etc..
  3057. // buffer MAX 1Ko
  3058. HTSEXT_API char* unescape_http(char* s) {
  3059.   char* tempo;
  3060.   int i,j=0;
  3061.   NOSTATIC_RESERVE(tempo, char, HTS_URLMAXSIZE*2);
  3062.   for (i=0;i<(int) strlen(s);i++) {
  3063.     if (s[i]=='%') {
  3064.       i++;
  3065.       tempo[j++]=(char) ehex(s+i);
  3066.       i++;    // sauter 2 caractËres finalement
  3067.     }
  3068.     /*
  3069.     NON a cause de trucs comme /home/0,1837,1|7|1173|Content,00.html
  3070.     else if (s[i]=='|') {                     // exemple: file:///C|Program%20Files...
  3071.       tempo[j++]=':';
  3072.     }
  3073.     */
  3074.     else
  3075.       tempo[j++]=s[i];
  3076.   }
  3077.   tempo[j++]='\0';
  3078.   return tempo;
  3079. }
  3080.  
  3081. // unescape in URL/URI ONLY what has to be escaped, to form a standard URL/URI
  3082. HTSEXT_API char* unescape_http_unharm(char* s, int no_high) {
  3083.   char* tempo;
  3084.   int i,j=0;
  3085.   NOSTATIC_RESERVE(tempo, char, HTS_URLMAXSIZE*2);
  3086.   for (i=0;i<(int) strlen(s);i++) {
  3087.     if (s[i]=='%') {
  3088.       int nchar=(char) ehex(s+i+1);
  3089.  
  3090.       int test = (  CHAR_RESERVED(nchar)
  3091.                 || CHAR_DELIM(nchar)
  3092.                 || CHAR_UNWISE(nchar)
  3093.                 || CHAR_LOW(nchar)        /* CHAR_SPECIAL */
  3094.                 || CHAR_XXAVOID(nchar) 
  3095.                 || (
  3096.                   (no_high)
  3097.                   &&
  3098.                   CHAR_HIG(nchar)
  3099.                 )
  3100.                 );
  3101.  
  3102.       if (!test) {
  3103.         tempo[j++]=(char) ehex(s+i+1);
  3104.         i+=2;
  3105.       } else {
  3106.         tempo[j++]='%';
  3107.       }
  3108.     }
  3109.     /*
  3110.     NON a cause de trucs comme /home/0,1837,1|7|1173|Content,00.html
  3111.     else if (s[i]=='|') {                     // exemple: file:///C|Program%20Files...
  3112.       tempo[j++]=':';
  3113.     }
  3114.     */
  3115.     else
  3116.       tempo[j++]=s[i];
  3117.   }
  3118.   tempo[j++]='\0';
  3119.   return tempo;
  3120. }
  3121.  
  3122. // remplacer " par %xx etc..
  3123. // buffer MAX 1Ko
  3124. HTSEXT_API void escape_spc_url(char* s) {
  3125.   x_escape_http(s,2);
  3126. }
  3127. // smith / john -> smith%20%2f%20john
  3128. HTSEXT_API void escape_in_url(char* s) {
  3129.   x_escape_http(s,1);
  3130. }
  3131. // smith / john -> smith%20/%20john
  3132. HTSEXT_API void escape_uri(char* s) {
  3133.   x_escape_http(s,3);
  3134. }
  3135. HTSEXT_API void escape_uri_utf(char* s) {
  3136.   x_escape_http(s,30);
  3137. }
  3138. HTSEXT_API void escape_check_url(char* s) {
  3139.   x_escape_http(s,0);
  3140. }
  3141. // same as escape_check_url, but returns char*
  3142. HTSEXT_API char* escape_check_url_addr(char* s) {
  3143.   char* adr;
  3144.   escape_check_url(adr = concat(s,""));
  3145.   return adr;
  3146. }
  3147.  
  3148.  
  3149. HTSEXT_API void x_escape_http(char* s,int mode) {
  3150.   while(*s) {
  3151.     int test=0;
  3152.     if (mode == 0)
  3153.       test=(strchr("\" ",*s)!=0);
  3154.     else if (mode==1) {
  3155.       test = (  CHAR_RESERVED(*s)
  3156.              || CHAR_DELIM(*s)
  3157.              || CHAR_UNWISE(*s)
  3158.              || CHAR_SPECIAL(*s)
  3159.              || CHAR_XXAVOID(*s) );
  3160.     }
  3161.     else if (mode==2)
  3162.       test=(strchr(" ",*s)!=0);           // n'escaper que espace
  3163.     else if (mode==3) {                   // Èchapper que ce qui est nÈcessaire
  3164.       test = (
  3165.                 CHAR_SPECIAL(*s)
  3166.              || CHAR_XXAVOID(*s) );
  3167.     }
  3168.     else if (mode==30) {                   // Èchapper que ce qui est nÈcessaire
  3169.       test = (
  3170.                 CHAR_LOW(*s)
  3171.              || CHAR_XXAVOID(*s) );
  3172.     }
  3173.  
  3174.     if (test) {
  3175.       char buffer[HTS_URLMAXSIZE*2];
  3176.       int n;
  3177.       n=(int)(unsigned char) *s;
  3178.       strcpybuff(buffer,s+1);
  3179.       sprintf(s,"%%%02x",n);
  3180.       strcatbuff(s,buffer);
  3181.     }
  3182.     s++;
  3183.   }
  3184. }
  3185.  
  3186.  
  3187. HTS_INLINE int ehexh(char c) {
  3188.   if ((c>='0') && (c<='9')) return c-'0';
  3189.   if ((c>='a') && (c<='f')) c-=('a'-'A');
  3190.   if ((c>='A') && (c<='F')) return (c-'A'+10);
  3191.   return 0;
  3192. }
  3193.  
  3194. HTS_INLINE int ehex(char* s) {
  3195.   return 16*ehexh(*s)+ehexh(*(s+1));
  3196.  
  3197. }
  3198.  
  3199. // concat, concatËne deux chaines et renvoi le rÈsultat
  3200. // permet d'allÈger grandement le code
  3201. // il faut savoir qu'on ne peut mettre plus de 16 concat() dans une expression
  3202. typedef struct {
  3203.   char buff[16][HTS_URLMAXSIZE*2*2];
  3204.   int rol;
  3205. } concat_strc;
  3206. char* concat(const char* a,const char* b) {
  3207.   concat_strc* strc;
  3208.   NOSTATIC_RESERVE(strc, concat_strc, 1);
  3209.   strc->rol=((strc->rol+1)%16);    // roving pointer
  3210.   strcpybuff(strc->buff[strc->rol],a);
  3211.   if (b) strcatbuff(strc->buff[strc->rol],b);
  3212.   return strc->buff[strc->rol];
  3213. }
  3214. // conversion fichier / -> antislash
  3215. #if HTS_DOSNAME
  3216. char* __fconv(char* a) {
  3217.   int i;
  3218.   for(i=0;i<(int) strlen(a);i++)
  3219.     if (a[i]=='/')  // convertir
  3220.       a[i]='\\';
  3221.   return a;
  3222. }
  3223. char* fconcat(char* a,char* b) {
  3224.   return __fconv(concat(a,b));
  3225. }
  3226. char* fconv(char* a) {
  3227.   return __fconv(concat(a,""));
  3228. }
  3229. #endif
  3230.  
  3231. /* / et \\ en / */
  3232. char* __fslash(char* a) {
  3233.   int i;
  3234.   for(i=0;i<(int) strlen(a);i++)
  3235.     if (a[i]=='\\')  // convertir
  3236.       a[i]='/';
  3237.   return a;
  3238. }
  3239. char* fslash(char* a) {
  3240.   return __fslash(concat(a,""));
  3241. }
  3242.  
  3243. // conversion minuscules, avec buffer
  3244. char* convtolower(char* a) {
  3245.   concat_strc* strc;
  3246.   NOSTATIC_RESERVE(strc, concat_strc, 1);
  3247.   strc->rol=((strc->rol+1)%16);    // roving pointer
  3248.   strcpybuff(strc->buff[strc->rol],a);
  3249.   hts_lowcase(strc->buff[strc->rol]);  // lower case
  3250.   return strc->buff[strc->rol];
  3251. }
  3252.  
  3253. // conversion en minuscules
  3254. void hts_lowcase(char* s) {
  3255.   int i;
  3256.   for(i=0;i<(int) strlen(s);i++)
  3257.     if ((s[i]>='A') && (s[i]<='Z'))
  3258.       s[i]+=('a'-'A');
  3259. }
  3260.  
  3261. // remplacer un caractËre d'une chaÓne dans une autre
  3262. HTS_INLINE void hts_replace(char *s,char from,char to) { 
  3263.   char* a;
  3264.   while ((a=strchr(s,from))!=NULL) {
  3265.     *a=to;
  3266.   }
  3267. }
  3268.  
  3269.  
  3270. // caractËre espace, guillemets, CR, LF etc..
  3271. /* SECTION OPTIMISEE:
  3272.   #define  is_space(c) (strchr(" \"\x0d\x0a\x09'",c)!=NULL)
  3273.   #define  is_realspace(c) (strchr(" \x0d\x0a\x09\x0c",c)!=NULL)
  3274. */
  3275. /*
  3276. HTS_INLINE int is_space(char c) {
  3277.   if (c==' ')  return 1;  // spc
  3278.   if (c=='"')  return 1;  // quote
  3279.   if (c==10)   return 1;  // lf
  3280.   if (c==13)   return 1;  // cr
  3281.   if (c=='\'') return 1;  // quote
  3282.   //if (c=='`')  return 1;  // backquote      << non
  3283.   if (c==9)    return 1;  // tab
  3284.   return 0;
  3285. }
  3286. */
  3287.  
  3288. // caractËre espace, CR, LF, TAB
  3289. /*
  3290. HTS_INLINE int is_realspace(char c) {
  3291.   if (c==' ')  return 1;  // spc
  3292.   if (c==10)   return 1;  // lf
  3293.   if (c==13)   return 1;  // cr
  3294.   if (c==9)    return 1;  // tab
  3295.   return 0;
  3296. }
  3297. */
  3298.  
  3299.  
  3300.  
  3301.  
  3302.  
  3303. // deviner type d'un fichier local..
  3304. // ex: fil="toto.gif" -> s="image/gif"
  3305. void guess_httptype(char *s,char *fil) {
  3306.   get_httptype(s,fil,1);
  3307. }
  3308. // idem
  3309. // flag: 1 si toujours renvoyer un type
  3310. void get_httptype(char *s,char *fil,int flag) {
  3311.   if (ishtml(fil)==1)
  3312.     strcpybuff(s,"text/html");
  3313.   else {
  3314.     char *a=fil+strlen(fil)-1;    
  3315.     while ( (*a!='.') && (*a!='/')  && (a>fil)) a--;
  3316.     if (*a=='.') {
  3317.       int ok=0;
  3318.       int j=0;
  3319.       a++;
  3320.       while( (!ok) && (strnotempty(hts_mime[j][1])) ) {
  3321.         if (strfield2(hts_mime[j][1],a)) {
  3322.           if (hts_mime[j][0][0]!='*') {    // Une correspondance existe
  3323.             strcpybuff(s,hts_mime[j][0]);
  3324.             ok=1;
  3325.           }
  3326.         }
  3327.         j++;
  3328.       }
  3329.       
  3330.       if (!ok) if (flag) sprintf(s,"application/%s",a);
  3331.     } else {
  3332.       if (flag) strcpybuff(s,"application/octet-stream");
  3333.     }
  3334.   }
  3335. }
  3336.  
  3337. // get type of fil (php)
  3338. // s: buffer (text/html) or NULL
  3339. // return: 1 if known by user
  3340. int get_userhttptype(int setdefs,char *s,char *ext) {
  3341.   char** buffer=NULL;
  3342.   NOSTATIC_RESERVE(buffer, char*, 1);
  3343.   if (setdefs) {
  3344.     *buffer=s;
  3345.     return 1;
  3346.   } else {
  3347.     if (s)
  3348.       s[0]='\0';
  3349.     if (!ext)
  3350.       return 0;
  3351.     if (*buffer) {
  3352.       char search[1024];
  3353.       char* detect;
  3354.       sprintf(search,"\n%s=",ext);    // php=text/html
  3355.       detect=strstr(*buffer,search);
  3356.       if (!detect) {
  3357.         sprintf(search,"\n%s\n",ext); // php\ncgi=text/html
  3358.         detect=strstr(*buffer,search);
  3359.       }
  3360.       if (detect) {
  3361.         detect=strchr(detect,'=');
  3362.         if (detect) {
  3363.           detect++;
  3364.           if (s) {
  3365.             char* a;
  3366.             a=strchr(detect,'\n');
  3367.             if (a) {
  3368.               strncatbuff(s,detect,(int) (a - detect));
  3369.             }
  3370.           }
  3371.           return 1;
  3372.         }
  3373.       }
  3374.     }
  3375.   }
  3376.   return 0;
  3377. }
  3378. // renvoyer extesion d'un type mime..
  3379. // ex: "image/gif" -> gif
  3380. void give_mimext(char *s,char *st) {   
  3381.   int ok=0;
  3382.   int j=0;
  3383.   s[0]='\0';
  3384.   while( (!ok) && (strnotempty(hts_mime[j][1])) ) {
  3385.     if (strfield2(hts_mime[j][0],st)) {
  3386.       if (hts_mime[j][1][0]!='*') {    // Une correspondance existe
  3387.         strcpybuff(s,hts_mime[j][1]);
  3388.         ok=1;
  3389.       }
  3390.     }
  3391.     j++;
  3392.   }
  3393.   // wrap "x" mimetypes, such as:
  3394.   // application/x-mp3
  3395.   // or
  3396.   // application/mp3
  3397.   if (!ok) {
  3398.     int p;
  3399.     char* a=NULL;
  3400.     if ((p=strfield(st,"application/x-")))
  3401.       a=st+p;
  3402.     else if ((p=strfield(st,"application/")))
  3403.       a=st+p;
  3404.     if (a) {
  3405.       if ((int)strlen(a) >= 1) {
  3406.         if ((int)strlen(a) <= 4) {
  3407.           strcpybuff(s,a);
  3408.           ok=1;
  3409.         }
  3410.       }
  3411.     }
  3412.   }
  3413. }
  3414. // extension connue?..
  3415. //  0 : non
  3416. //  1 : oui
  3417. //  2 : html
  3418. int is_knowntype(char *fil) {
  3419.   int j=0;
  3420.   if (!fil)
  3421.     return 0;
  3422.   while(strnotempty(hts_mime[j][1])) {
  3423.     if (strfield2(hts_mime[j][1],fil)) {
  3424.       if (strfield2(hts_mime[j][0],"text/html"))
  3425.         return 2;
  3426.       else
  3427.         return 1;
  3428.     }
  3429.     j++;
  3430.   }
  3431.  
  3432.   // Known by user?
  3433.   return (is_userknowntype(fil));
  3434. }
  3435. // extension : html,gif..
  3436. char* get_ext(char *fil) {
  3437.   char* fil_noquery;
  3438.   char *a=fil+strlen(fil)-1;    
  3439.   NOSTATIC_RESERVE(fil_noquery, char, HTS_URLMAXSIZE*2);
  3440.  
  3441.   while ( (*a!='.') && (*a!='/')  && (a>fil)) a--;
  3442.   if (*a=='.') {
  3443.     fil_noquery[0]='\0';
  3444.     a++;  // pointer sur extension
  3445.     strncatbuff(fil_noquery,a,HTS_URLMAXSIZE);
  3446.     a=strchr(fil_noquery,'?');
  3447.     if (a)
  3448.       *a='\0';
  3449.     return concat(fil_noquery,"");
  3450.   }
  3451.   else
  3452.     return "";
  3453. }
  3454. // known type?..
  3455. //  0 : no
  3456. //  1 : yes
  3457. //  2 : html
  3458. // setdefs : set mime buffer:
  3459. //   file=(char*) "asp=text/html\nphp=text/html\n"
  3460. int is_userknowntype(char *fil) {
  3461.   char mime[1024];
  3462.   if (!fil)
  3463.     return 0;
  3464.   if (!strnotempty(fil))
  3465.     return 0;
  3466.   mime[0]='\0';
  3467.   get_userhttptype(0,mime,fil);
  3468.   if (!strnotempty(mime))
  3469.     return 0;
  3470.   else if (strfield2(mime,"text/html"))
  3471.     return 2;
  3472.   else
  3473.     return 1;
  3474. }
  3475.  
  3476. // page dynamique?
  3477. // is_dyntype(get_ext("foo.asp"))
  3478. int is_dyntype(char *fil) {
  3479.   int j=0;
  3480.   if (!fil)
  3481.     return 0;
  3482.   if (!strnotempty(fil))
  3483.     return 0;
  3484.   while(strnotempty(hts_ext_dynamic[j])) {
  3485.     if (strfield2(hts_ext_dynamic[j],fil)) {
  3486.       return 1;
  3487.     }
  3488.     j++;
  3489.   }
  3490.   return 0;
  3491. }
  3492.  
  3493. // types critiques qui ne doivent pas Ítre changÈs car renvoyÈs par des serveurs qui ne
  3494. // connaissent pas le type
  3495. int may_unknown(char* st) {
  3496.   int j=0;
  3497.   // types mÈdia
  3498.   if (may_be_hypertext_mime(st))
  3499.     return 1;
  3500.   while(strnotempty(hts_mime_keep[j])) {
  3501.     if (strfield2(hts_mime_keep[j],st)) {      // trouvÈ
  3502.       return 1;
  3503.     }
  3504.     j++;
  3505.   }    
  3506.   return 0;
  3507. }
  3508.  
  3509.  
  3510.  
  3511. // -- Utils fichiers
  3512.  
  3513. // pretty print for i/o
  3514. void fprintfio(FILE* fp,char* buff,char* prefix) {
  3515.   char nl=1;
  3516.   while(*buff) {
  3517.     switch(*buff) {
  3518.     case 13: break;
  3519.     case 10:
  3520.       fprintf(fp,"\r\n");
  3521.       nl=1;
  3522.     break;
  3523.     default:
  3524.       if (nl)
  3525.         fprintf(fp,prefix);
  3526.       nl=0;
  3527.       fputc(*buff,fp);
  3528.     }
  3529.     buff++;
  3530.   }
  3531. }
  3532.  
  3533. /* Le fichier existe-t-il? (ou est-il accessible?) */
  3534. int fexist(char* s) {
  3535.   FILE* fp;
  3536.   if (strnotempty(s)==0)     // nom vide: non trouvÈ
  3537.     return 0;
  3538.   fp=fopen(fconv(s),"rb");
  3539.   if (fp!=NULL) fclose(fp);
  3540.   return (fp!=NULL);
  3541. } 
  3542.  
  3543. /* Taille d'un fichier, -1 si n'existe pas */
  3544. /* fp->_cnt ne fonctionne pas sur toute les plate-formes :-(( */
  3545. /* Note: NOT YET READY FOR 64-bit */
  3546. //LLint fsize(char* s) {
  3547. int fsize(char* s) {
  3548.   /*
  3549. #if HTS_WIN
  3550.   HANDLE hFile;
  3551.   DWORD dwSizeHigh = 0;
  3552.   DWORD dwSizeLow  = 0;
  3553.   hFile = CreateFile(s,0,0,NULL,OPEN_EXISTING,0,NULL);
  3554.   if (hFile) {
  3555.     dwSizeLow = GetFileSize (hFile, & dwSizeHigh) ;
  3556.     CloseHandle(hFile);
  3557.     if (dwSizeLow != 0xFFFFFFFF)
  3558.       return (dwSizeLow & (dwSizeHigh<<32));
  3559.     else
  3560.       return -1;
  3561.   } else
  3562.     return -1;
  3563. #else
  3564.     */
  3565.   FILE* fp;
  3566.   if (strnotempty(s)==0)     // nom vide: erreur
  3567.     return -1;
  3568.   fp=fopen(fconv(s),"rb");
  3569.   if (fp!=NULL) {
  3570.     int i;
  3571.     fseek(fp,0,SEEK_END);
  3572.     i=ftell(fp);
  3573.     fclose(fp);
  3574.     return i;
  3575.   } else return -1;
  3576.   /*
  3577. #endif
  3578.   */
  3579. }
  3580.  
  3581. int fpsize(FILE* fp) {
  3582.   int oldpos,size;
  3583.   if (!fp)
  3584.     return -1;
  3585.   oldpos=ftell(fp);
  3586.   fseek(fp,0,SEEK_END);
  3587.   size=ftell(fp);
  3588.   fseek(fp,oldpos,SEEK_SET);
  3589.   return size;
  3590. }
  3591.  
  3592. /* root dir, with ending / */
  3593. typedef struct {
  3594.   char path[1024+4];
  3595.   int init;
  3596. } hts_rootdir_strc;
  3597. HTSEXT_API char* hts_rootdir(char* file) {
  3598.   static hts_rootdir_strc strc = {"", 0};
  3599.   //NOSTATIC_RESERVE(strc, hts_rootdir_strc, 1);
  3600.   if (file) {
  3601.     if (!strc.init) {
  3602.       strc.path[0]='\0';
  3603.       strc.init=1;
  3604.       if (strnotempty(file)) {
  3605.         char* a;
  3606.         strcpybuff(strc.path,file);
  3607.         while((a=strrchr(strc.path,'\\'))) *a='/';
  3608.         if ((a=strrchr(strc.path,'/'))) {
  3609.           *(a+1)='\0';
  3610.         } else
  3611.           strc.path[0]='\0';
  3612.       }
  3613.       if (!strnotempty(strc.path)) {
  3614.         if( getcwd( strc.path, 1024 ) == NULL )
  3615.             strc.path[0]='\0';
  3616.         else
  3617.           strcatbuff(strc.path,"/");
  3618.       }
  3619.     }
  3620.     return NULL;
  3621.   } else if (strc.init)
  3622.     return strc.path;
  3623.   else
  3624.     return "";
  3625. }
  3626.  
  3627.  
  3628.  
  3629. HTSEXT_API hts_stat_struct HTS_STAT;
  3630. //
  3631. // return  number of downloadable bytes, depending on rate limiter
  3632. // see engine_stats() routine, too
  3633. // this routine works quite well for big files and regular ones, but apparently the rate limiter has
  3634. // some problems with very small files (rate too high)
  3635. LLint check_downloadable_bytes(int rate) {
  3636.   if (rate>0) {
  3637.     TStamp time_now;
  3638.     TStamp elapsed_useconds;
  3639.     LLint bytes_transfered_during_period;
  3640.     LLint left;
  3641.  
  3642.     // get the older timer
  3643.     int id_timer = (HTS_STAT.istat_idlasttimer + 1) % 2;
  3644.  
  3645.     time_now=mtime_local();
  3646.     elapsed_useconds = time_now - HTS_STAT.istat_timestart[id_timer];
  3647.     // NO totally stupid - elapsed_useconds+=1000;      // for the next second, too
  3648.     bytes_transfered_during_period = (HTS_STAT.HTS_TOTAL_RECV-HTS_STAT.istat_bytes[id_timer]);
  3649.     
  3650.     left = ((rate * elapsed_useconds)/1000) - bytes_transfered_during_period;
  3651.     if (left <= 0)
  3652.       left = 0;
  3653.     
  3654.     return left;
  3655.   } else
  3656.     return TAILLE_BUFFER;
  3657. }
  3658.  
  3659. //
  3660. // 0 : OK
  3661. // 1 : slow down
  3662. #if 0
  3663. int HTS_TOTAL_RECV_CHECK(int var) {
  3664.   if (HTS_STAT.HTS_TOTAL_RECV_STATE)
  3665.     return 1;
  3666.     /*
  3667.     {
  3668.     if (HTS_STAT.HTS_TOTAL_RECV_STATE==3) { 
  3669.       var = min(var,32); 
  3670.       Sleep(250); 
  3671.     } else if (HTS_STAT.HTS_TOTAL_RECV_STATE==2) { 
  3672.       var = min(var,256); 
  3673.       Sleep(100); 
  3674.     } else { 
  3675.       var/=2; 
  3676.       if (var<=0) var=1; 
  3677.       Sleep(50); 
  3678.     } 
  3679.   }
  3680.     */
  3681.   return 0;
  3682. }
  3683. #endif
  3684.  
  3685. // Lecture dans buff de size octets au maximum en utilisant la socket r (structure htsblk)
  3686. // >0 : data received
  3687. // == 0 : not yet data
  3688. // <0 : no more data or error
  3689. HTS_INLINE int hts_read(htsblk* r,char* buff,int size) {
  3690.   int retour;
  3691.   //  return read(soc,buff,size);
  3692.   if (r->is_file) {
  3693. #if HTS_WIDE_DEBUG    
  3694.     DEBUG_W("read\n");
  3695. #endif
  3696.     if (r->fp)
  3697.       retour=fread(buff,1,size,r->fp);
  3698.     else
  3699.       retour=-1;
  3700.   } else {
  3701. #if HTS_WIDE_DEBUG    
  3702.     DEBUG_W("recv\n");
  3703.     if (r->soc==INVALID_SOCKET)
  3704.       printf("!!WIDE_DEBUG ERROR, soc==INVALID hts_read\n");
  3705. #endif
  3706.     //HTS_TOTAL_RECV_CHECK(size);         // Diminuer au besoin si trop de donnÈes reÁues
  3707. #if HTS_USEOPENSSL
  3708.     if (SSL_is_available && r->ssl) {
  3709.       retour = SSL_read(r->ssl_con, buff, size);
  3710.       if (retour <= 0) {
  3711.         int err_code = SSL_get_error(r->ssl_con, retour);
  3712.         if (
  3713.           (err_code == SSL_ERROR_WANT_READ)
  3714.           ||
  3715.           (err_code == SSL_ERROR_WANT_WRITE)
  3716.           ) 
  3717.         {
  3718.           retour = 0;             /* no data yet (ssl cache) */
  3719.         } else {
  3720.           retour = -1;            /* eof or error */
  3721.         }
  3722.       }
  3723.     } else {
  3724. #endif
  3725.     retour=recv(r->soc,buff,size,0);
  3726.   }
  3727.   if (retour > 0)    // compter flux entrant
  3728.     HTS_STAT.HTS_TOTAL_RECV+=retour;
  3729. #if HTS_USEOPENSSL
  3730.   }
  3731. #endif
  3732. #if HTS_WIDE_DEBUG    
  3733.   DEBUG_W("recv/read done\n");
  3734. #endif
  3735.   return retour;
  3736. }
  3737.  
  3738.  
  3739. // -- Gestion cache DNS --
  3740. // 'RX98
  3741. #if HTS_DNSCACHE
  3742.  
  3743. // 'capsule' contenant uniquement le cache
  3744. t_dnscache* _hts_cache(void) {
  3745.   t_dnscache* cache;
  3746.   NOSTATIC_RESERVE(cache, t_dnscache, 1);
  3747.   return cache;
  3748. }
  3749.  
  3750. // lock le cache dns pour tout opÈration d'ajout
  3751. // plus prudent quand plusieurs threads peuvent Ècrire dedans..
  3752. // -1: status? 0: libÈrer 1:locker
  3753.  
  3754. /* 
  3755.   Simple lock function for cache
  3756.  
  3757.   Return value: always 0
  3758.   Parameter:
  3759.   1 wait for lock (mutex) available and lock it
  3760.   0 unlock the mutex
  3761.   [-1 check if locked (always return 0 with mutex)]
  3762.   -999 initialize
  3763. */
  3764. #if USE_BEGINTHREAD
  3765. int _hts_lockdns(int i) {
  3766.   static PTHREAD_LOCK_TYPE hMutex; 
  3767.   return htsSetLock(&hMutex,i);
  3768. }
  3769. #else
  3770. int _hts_lockdns(int i) {
  3771.   int l=0;
  3772.   if (i>=0)
  3773.     l=i;
  3774.   return l;
  3775. }
  3776. #endif
  3777.  
  3778. // routine pour le cache - retour optionnel ‡ donner ‡ chaque fois
  3779. // NULL: nom non encore testÈ dans le cache
  3780. // si h_length==0 alors le nom n'existe pas dans le dns
  3781. t_hostent* _hts_ghbn(t_dnscache* cache,char* iadr,t_hostent* retour) {
  3782.   // attendre que le cache dns soit prÍt
  3783.   while(_hts_lockdns(-1));  // attendre libÈration
  3784.   _hts_lockdns(1);          // locker
  3785.  
  3786.   while(1) {
  3787.     if (strcmp(cache->iadr,iadr)==0) {  // ok trouvÈ
  3788.       if (cache->host_length>0) {  // entrÈe valide
  3789.         if (retour->h_addr_list[0])
  3790.           memcpy(retour->h_addr_list[0], cache->host_addr, cache->host_length);
  3791.         retour->h_length=cache->host_length;
  3792.       } else if (cache->host_length==0) {  // en cours
  3793.         _hts_lockdns(0);          // dÈlocker
  3794.         return NULL;
  3795.       } else {                    // erreur dans le dns, dÈja vÈrifiÈ
  3796.         if (retour->h_addr_list[0])
  3797.           retour->h_addr_list[0][0]='\0';
  3798.         retour->h_length=0;  // erreur, n'existe pas
  3799.       }
  3800.       _hts_lockdns(0);          // dÈlocker
  3801.       return retour;
  3802.     } else {    // on a pas encore trouvÈ
  3803.       if (cache->n!=NULL) { // chercher encore
  3804.         cache=cache->n;   // suivant!
  3805.       } else {
  3806.         _hts_lockdns(0);          // dÈlocker
  3807.         return NULL;    // non prÈsent        
  3808.       }
  3809.     }    
  3810.   }
  3811. }
  3812.  
  3813. // tester si iadr a dÈja ÈtÈ testÈ (ou en cours de test)
  3814. // 0 non encore
  3815. // 1 ok
  3816. // 2 non prÈsent
  3817. int hts_dnstest(char* _iadr) {
  3818.   char* iadr;
  3819.   t_dnscache* cache=_hts_cache();  // adresse du cache 
  3820.   NOSTATIC_RESERVE(iadr, char, HTS_URLMAXSIZE*2);
  3821.  
  3822.   // sauter user:pass@ Èventuel
  3823.   strcpybuff(iadr,jump_identification(_iadr));
  3824.   // couper Èventuel :
  3825.   {
  3826.     char *a;
  3827.     if ( (a=jump_toport(iadr)) )
  3828.       *a='\0';
  3829.   }
  3830.  
  3831. #if HTS_WIN
  3832.   if (inet_addr(iadr)!=INADDR_NONE)  // numÈrique
  3833. #else
  3834.   if (inet_addr(iadr)!=(in_addr_t) -1 )  // numÈrique
  3835. #endif
  3836.     return 1;
  3837.  
  3838.   while(_hts_lockdns(-1));  // attendre libÈration
  3839.   _hts_lockdns(1);          // locker
  3840.   while(1) {
  3841.     if (strcmp(cache->iadr,iadr)==0) {  // ok trouvÈ
  3842.       _hts_lockdns(0);          // dÈlocker
  3843.       return 1;    // prÈsent!
  3844.     } else {    // on a pas encore trouvÈ
  3845.       if (cache->n!=NULL) { // chercher encore
  3846.         cache=cache->n;   // suivant!
  3847.       } else {
  3848.         _hts_lockdns(0);          // dÈlocker
  3849.         return 2;    // non prÈsent        
  3850.       }
  3851.     }    
  3852.   }
  3853. }
  3854.  
  3855.  
  3856. t_hostent* vxgethostbyname(char* hostname, void* v_buffer) {
  3857.   t_fullhostent* buffer = (t_fullhostent*) v_buffer;
  3858.   /* Clear */
  3859.   fullhostent_init(buffer);
  3860.  
  3861.   /* Protection */
  3862.   if (!strnotempty(hostname)) {
  3863.     return NULL;
  3864.   }
  3865.  
  3866.   /* 
  3867.     Strip [] if any : [3ffe:b80:1234:1::1] 
  3868.     The resolver doesn't seem to handle IP6 addresses in brackets
  3869.   */
  3870.   if ((hostname[0] == '[') && (hostname[strlen(hostname)-1] == ']')) {
  3871.     char tempo[HTS_URLMAXSIZE*2];
  3872.     tempo[0]='\0';
  3873.     strncatbuff(tempo, hostname+1, strlen(hostname)-2);
  3874.     strcpybuff(hostname, tempo);
  3875.   }
  3876.  
  3877.   {
  3878. #if HTS_INET6==0
  3879.   /*
  3880.   ipV4 resolver
  3881.     */
  3882.     t_hostent* hp=gethostbyname(hostname);
  3883.     if (hp!=NULL) {
  3884.       if ( (hp->h_length) && ( ((unsigned int) hp->h_length) <= buffer->addr_maxlen) ) {
  3885.         memcpy(buffer->hp.h_addr_list[0], hp->h_addr_list[0], hp->h_length);
  3886.         buffer->hp.h_length = hp->h_length;
  3887.         return &(buffer->hp);
  3888.       }
  3889.     }
  3890. #else
  3891.     /*
  3892.     ipV6 resolver
  3893.     */
  3894.     /*
  3895.     int error_num=0;
  3896.     t_hostent* hp=getipnodebyname(hostname, AF_INET6, AI_DEFAULT, &error_num);
  3897.     oops, deprecated :(
  3898.     */
  3899.     struct addrinfo* res = NULL;
  3900.     struct addrinfo hints;
  3901.     memset(&hints, 0, sizeof(hints));
  3902.     if (IPV6_resolver == 1)        // V4 only (for bogus V6 entries)
  3903.       hints.ai_family = PF_INET;
  3904.     else if (IPV6_resolver == 2)   // V6 only (for testing V6 only)
  3905.       hints.ai_family = PF_INET6;
  3906.     else                           // V4 + V6
  3907.       hints.ai_family = PF_UNSPEC;
  3908.     hints.ai_socktype = SOCK_STREAM;
  3909.     hints.ai_protocol = IPPROTO_TCP;
  3910.     if (getaddrinfo(hostname, NULL, &hints, &res) == 0) {
  3911.       if (res) {
  3912.         if ( (res->ai_addr) && (res->ai_addrlen) && (res->ai_addrlen <= buffer->addr_maxlen) ) {
  3913.           memcpy(buffer->hp.h_addr_list[0], res->ai_addr, res->ai_addrlen);
  3914.           buffer->hp.h_length = res->ai_addrlen;
  3915.           freeaddrinfo(res);
  3916.           return &(buffer->hp);
  3917.         }
  3918.       }
  3919.     }
  3920.     if (res) {
  3921.       freeaddrinfo(res);
  3922.     }
  3923.     
  3924. #endif
  3925.   }
  3926.   return NULL;
  3927. }
  3928.  
  3929. // cache dns interne ‡ HTS // ** FREE A FAIRE sur la chaine
  3930. t_hostent* hts_gethostbyname(char* _iadr, void* v_buffer) {
  3931.   char iadr[HTS_URLMAXSIZE*2];
  3932.   t_fullhostent* buffer = (t_fullhostent*) v_buffer;
  3933.   t_dnscache* cache=_hts_cache();  // adresse du cache
  3934.   t_hostent* hp;
  3935.  
  3936.   /* Clear */
  3937.   fullhostent_init(buffer);
  3938.  
  3939.   strcpybuff(iadr,jump_identification(_iadr));
  3940.   // couper Èventuel :
  3941.   {
  3942.     char *a;
  3943.     if ( (a=jump_toport(iadr)) )
  3944.       *a='\0';
  3945.   }
  3946.  
  3947.   // effacer structure de retour, crÈer nouvelle
  3948.   /*
  3949.   memset(&host, 0, sizeof(t_hostent));  
  3950.   host.h_addr_list=he;
  3951.   he[0]=NULL;
  3952.   he[1]=NULL;  
  3953.   host.h_length=0;  
  3954.   */
  3955.   cache->iadr[0]='*';
  3956.   cache->iadr[1]='\0';
  3957.   
  3958.   /* get IP from the dns cache */
  3959.   hp = _hts_ghbn(cache, iadr, &buffer->hp);
  3960.   if (hp) {
  3961.     if (hp->h_length>0)
  3962.       return hp;
  3963.     else
  3964.       return NULL;    // entrÈe erronÈe (erreur DNS) dans le DNS
  3965.   } else {  // non prÈsent dans le cache dns, tester
  3966.     t_dnscache* c=cache;
  3967.     while(c->n) c=c->n;    // calculer queue
  3968.     
  3969. #if HTS_WIDE_DEBUG    
  3970.     DEBUG_W("gethostbyname\n");
  3971. #endif      
  3972. #if HDEBUG
  3973.     printf("gethostbyname (not in cache)\n");
  3974. #endif
  3975.     {
  3976.       unsigned long inetaddr;
  3977. #if HTS_WIN
  3978.       if ((inetaddr=inet_addr(iadr))==INADDR_NONE) {
  3979. #else
  3980.       if ((inetaddr=inet_addr(iadr))==(in_addr_t) -1 ) {
  3981. #endif        
  3982. #if DEBUGDNS 
  3983.         printf("resolving (not cached) %s\n",iadr);
  3984. #endif
  3985.         hp=vxgethostbyname(iadr, buffer);  // calculer IP host
  3986.       } else {     // numÈrique, convertir sans passer par le dns
  3987.         buffer->hp.h_addr_list[0]=(char*) &inetaddr;
  3988.         buffer->hp.h_length=4;
  3989.         hp=&buffer->hp;
  3990.       }
  3991.     }
  3992. #if HTS_WIDE_DEBUG    
  3993.     DEBUG_W("gethostbyname done\n");
  3994. #endif
  3995.     cache->n=(t_dnscache*) calloct(1,sizeof(t_dnscache));
  3996.     if (cache->n!=NULL) {
  3997.       strcpybuff(cache->n->iadr,iadr);
  3998.       if (hp!=NULL) {
  3999.         memcpy(cache->n->host_addr, hp->h_addr_list[0], hp->h_length);
  4000.         cache->n->host_length=hp->h_length;
  4001.       } else {
  4002.         cache->n->host_addr[0]='\0';
  4003.         cache->n->host_length=0;  // non existant dans le dns
  4004.       }
  4005.       cache->n->n=NULL;
  4006.       return hp;
  4007.     } else {  // on peut pas noter, mais on peut renvoyer le rÈsultat
  4008.       return hp;
  4009.     }        
  4010.   }  // retour hp du cache
  4011. }
  4012.  
  4013. #else
  4014. HTS_INLINE t_hostent* hts_gethostbyname(char* iadr, t_fullhostent* buffer) {
  4015.   t_hostent* retour;
  4016. #if HTS_WIDE_DEBUG    
  4017.   DEBUG_W("gethostbyname (2)\n");
  4018. #endif
  4019. #if DEBUGDNS 
  4020.     printf("blocking method gethostbyname() in progress for %s\n",iadr);
  4021. #endif
  4022.   retour=vxgethostbyname(jump_identification(iadr), );
  4023. #if HTS_WIDE_DEBUG    
  4024.   DEBUG_W("gethostbyname (2) done\n");
  4025. #endif
  4026.   return retour;
  4027. }
  4028. #endif
  4029.  
  4030.  
  4031. // --- Tracage des mallocs() ---
  4032. #ifdef HTS_TRACE_MALLOC
  4033. //#define htsLocker(A, N) htsLocker(A, N)
  4034. #define htsLocker(A, N) do {} while(0)
  4035. static mlink trmalloc = {NULL,0,0,NULL};
  4036. static int trmalloc_id=0;
  4037. static PTHREAD_LOCK_TYPE* mallocMutex = NULL;
  4038. static void hts_meminit(void) {
  4039.   //if (mallocMutex == NULL) {
  4040.   //  mallocMutex = calloc(sizeof(*mallocMutex), 1);
  4041.   //  htsLocker(mallocMutex, -999);
  4042.   //}
  4043. }
  4044. void* hts_malloc(size_t len) {
  4045.   void* adr;
  4046.   hts_meminit();
  4047.   htsLocker(mallocMutex, 1);
  4048.   fassert(len > 0);
  4049.   adr = hts_xmalloc(len, 0);
  4050.   htsLocker(mallocMutex, 0);
  4051.   return adr;
  4052. }
  4053. void* hts_calloc(size_t len,size_t len2) {
  4054.   void* adr;
  4055.   hts_meminit();
  4056.   fassert(len > 0);
  4057.   fassert(len2 > 0);
  4058.   htsLocker(mallocMutex, 1);
  4059.   adr = hts_xmalloc(len, len2);
  4060.   htsLocker(mallocMutex, 0);
  4061.   memset(adr, 0, len * len2);
  4062.   return adr;
  4063. }
  4064. void* hts_xmalloc(size_t len,size_t len2) {
  4065.   mlink* lnk = (mlink*) calloc(1,sizeof(mlink));
  4066.   fassert(lnk != NULL);
  4067.   fassert(len > 0);
  4068.   fassert(len2 >= 0);
  4069.   if (lnk) {
  4070.     void*  r   = NULL;
  4071.     int size, bsize = sizeof(t_htsboundary);
  4072.     if (len2)
  4073.       size = len * len2;
  4074.     else
  4075.       size = len;
  4076.     size += ((bsize - (size % bsize)) % bsize);  /* check alignement */
  4077.     r = malloc(size + bsize*2);
  4078.     fassert(r != NULL);
  4079.     if (r) {
  4080.       * ( (t_htsboundary*) ((char*) r ) ) 
  4081.         = * ( (t_htsboundary*) ( (char*) r + size + bsize ) )
  4082.         = htsboundary;
  4083.       ((char*) r) += bsize;    /* boundary */
  4084.       lnk->adr = r;
  4085.       lnk->len = size;
  4086.       lnk->id = trmalloc_id++;
  4087.       lnk->next = trmalloc.next;
  4088.       trmalloc.next = lnk;
  4089.       return r;
  4090.     } else {
  4091.       free(lnk);
  4092.     }
  4093.   }
  4094.   return NULL;
  4095. }
  4096. void hts_free(void* adr) {
  4097.   mlink* lnk = &trmalloc;
  4098.   int bsize = sizeof(t_htsboundary);
  4099.   fassert(adr != NULL);
  4100.   if (!adr) {
  4101.     return;
  4102.   }
  4103.   htsLocker(mallocMutex, 1);
  4104.   while(lnk->next != NULL) {
  4105.     if (lnk->next->adr == adr) {
  4106.       mlink* blk_free=lnk->next;
  4107.       fassert(blk_free->id != -1);
  4108.       fassert( * ( (t_htsboundary*) ( (char*) adr - bsize ) ) == htsboundary );
  4109.       fassert( * ( (t_htsboundary*) ( (char*) adr + blk_free->len ) ) == htsboundary );
  4110.       lnk->next=lnk->next->next;
  4111.       free((void*) blk_free);
  4112.       //blk_free->id=-1;
  4113.       free((char*) adr - bsize);
  4114.       htsLocker(mallocMutex, 0);
  4115.       return;
  4116.     }
  4117.     lnk = lnk->next;
  4118.     fassert(lnk->next != NULL);
  4119.   }
  4120.   free(adr);
  4121.   htsLocker(mallocMutex, 0);
  4122. }
  4123. void* hts_realloc(void* adr,size_t len) {
  4124.   int bsize = sizeof(t_htsboundary);
  4125.   len += ((bsize - (len % bsize)) % bsize);  /* check alignement */
  4126.   if (adr != NULL) {
  4127.     mlink* lnk = &trmalloc;
  4128.     htsLocker(mallocMutex, 1);
  4129.     while(lnk->next != NULL)  {
  4130.       if (lnk->next->adr==adr) {
  4131.         {
  4132.           mlink* blk_free=lnk->next;
  4133.           fassert(blk_free->id != -1);
  4134.           fassert( * ( (t_htsboundary*) ( (char*) adr - bsize ) ) == htsboundary );
  4135.           fassert( * ( (t_htsboundary*) ( (char*) adr + blk_free->len ) ) == htsboundary );
  4136.         }
  4137.         adr = realloc((char*) adr - bsize, len + bsize * 2);
  4138.         fassert(adr != NULL);
  4139.         lnk->next->adr = (char*) adr + bsize;
  4140.         lnk->next->len = len;
  4141.         * ( (t_htsboundary*) ( (char*) adr ) ) 
  4142.           = * ( (t_htsboundary*) ( (char*) adr + len + bsize) ) 
  4143.           = htsboundary;
  4144.         htsLocker(mallocMutex, 0);
  4145.         return (char*) adr + bsize;
  4146.       }
  4147.       lnk = lnk->next;
  4148.       fassert(lnk->next != NULL);
  4149.     }
  4150.     htsLocker(mallocMutex, 0);
  4151.   }
  4152.   return hts_malloc(len);
  4153. }
  4154. mlink* hts_find(char* adr) {
  4155.   char* stkframe = (char*) &stkframe;
  4156.   mlink* lnk = &trmalloc;
  4157.   int bsize = sizeof(t_htsboundary);
  4158.   fassert(adr != NULL);
  4159.   if (!adr) {
  4160.     return NULL;
  4161.   }
  4162.   htsLocker(mallocMutex, 1);
  4163.   while(lnk->next != NULL) {
  4164.     if (adr >= lnk->next->adr && adr <= lnk->next->adr + lnk->next->len) {   /* found */
  4165.       htsLocker(mallocMutex, 0);
  4166.       return lnk->next;
  4167.     }
  4168.     lnk = lnk->next;
  4169.   }
  4170.   htsLocker(mallocMutex, 0);
  4171.   {
  4172.     int depl = (int) (adr - stkframe);
  4173.     if (depl < 0) depl = -depl;
  4174.     //fassert(depl < 512000);   /* near the stack frame.. doesn't look like malloc but stack variable */
  4175.     return NULL;
  4176.   }
  4177. }
  4178. // check the malloct() and calloct() trace stack
  4179. void  hts_freeall(void) {
  4180.   int bsize = sizeof(t_htsboundary);
  4181.   while(trmalloc.next) {
  4182. #if MEMDEBUG
  4183.     printf("* block %d\t not released: at %d\t (%d\t bytes)\n",trmalloc.next->id,trmalloc.next->adr,trmalloc.next->len);
  4184. #endif
  4185.     if (trmalloc.next->id != -1) {
  4186.       free((char*) trmalloc.next->adr - bsize);
  4187.     }
  4188.   }
  4189. }
  4190. #endif
  4191.  
  4192.  
  4193. // -- divers //
  4194.  
  4195. // cut path and project name
  4196. // patch also initial path
  4197. void cut_path(char* fullpath,char* path,char* pname) {
  4198.   path[0]=pname[0]='\0';
  4199.   if (strnotempty(fullpath)) {
  4200.     if ((fullpath[strlen(fullpath)-1]=='/') || (fullpath[strlen(fullpath)-1]=='\\'))
  4201.       fullpath[strlen(fullpath)-1]='\0';
  4202.     if (strlen(fullpath)>1) {
  4203.       char* a;
  4204.       while( (a=strchr(fullpath,'\\')) ) *a='/';     // remplacer par /
  4205.       a=fullpath+strlen(fullpath)-2;
  4206.       while( (*a!='/') && ( a > fullpath)) a--;
  4207.       if (*a=='/') a++;
  4208.       strcpybuff(pname,a);
  4209.       strncatbuff(path,fullpath,(int) (a - fullpath));
  4210.     }
  4211.   }
  4212. }
  4213.  
  4214.  
  4215.  
  4216. // -- Gestion protocole ftp --
  4217.  
  4218. #if HTS_WIN
  4219. int ftp_available(void) {
  4220.   return 1;
  4221. }
  4222. #else
  4223. int ftp_available(void) {
  4224.   return 1;   // ok!
  4225.   //return 0;   // SOUS UNIX, PROBLEMES
  4226. }
  4227. #endif
  4228.  
  4229.  
  4230.  
  4231. HTSEXT_API int hts_init(void) {
  4232.   static int hts_init_ok = 0;
  4233.  
  4234.   /* Ensure external modules are loaded */
  4235.   htspe_init();
  4236.  
  4237.   if (!hts_init_ok) {
  4238.     hts_init_ok = 1;
  4239.     // default wrappers
  4240.     htswrap_init();
  4241.     htswrap_add("init",htsdefault_init);
  4242.     htswrap_add("free",htsdefault_uninit);
  4243.     htswrap_add("start",htsdefault_start);
  4244.     htswrap_add("change-options",htsdefault_chopt);
  4245.     htswrap_add("end",htsdefault_end);
  4246.     htswrap_add("check-html",htsdefault_checkhtml);
  4247.     htswrap_add("loop",htsdefault_loop);
  4248.     htswrap_add("query",htsdefault_query);
  4249.     htswrap_add("query2",htsdefault_query2);
  4250.     htswrap_add("query3",htsdefault_query3);
  4251.     htswrap_add("check-link",htsdefault_check);
  4252.     htswrap_add("pause",htsdefault_pause);
  4253.     htswrap_add("save-file",htsdefault_filesave);
  4254.     htswrap_add("link-detected",htsdefault_linkdetected);
  4255.     htswrap_add("transfer-status",htsdefault_xfrstatus);
  4256.     htswrap_add("save-name",htsdefault_savename);
  4257.   }
  4258.   
  4259. #if HTS_USEOPENSSL
  4260.   /*
  4261.   Initialize the OpensSSL library
  4262.   */
  4263.   if (!openssl_ctx && SSL_is_available) {
  4264.     if (SSL_load_error_strings) SSL_load_error_strings();
  4265.     SSL_library_init();
  4266.     ///if (SSL_load_error_strings)  SSL_load_error_strings();
  4267.     //if (ERR_load_crypto_strings) ERR_load_crypto_strings();
  4268.     // if (ERR_load_SSL_strings)    ERR_load_SSL_strings(); ???!!!
  4269.     // OpenSSL_add_all_algorithms();
  4270.     openssl_ctx = SSL_CTX_new(SSLv23_client_method());
  4271.     if (!openssl_ctx) {
  4272.       fprintf(stderr, "fatal: unable to initialize TLS: SSL_CTX_new(SSLv23_client_method)\n");
  4273.       abortLog("unable to initialize TLS: SSL_CTX_new(SSLv23_client_method)");
  4274.       abort();
  4275.     }
  4276.   }
  4277. #endif
  4278.   
  4279.   /* Init vars and thread-specific values */
  4280.   hts_initvar();
  4281.   
  4282.   /* initialiser structcheck */
  4283.   structcheck_init(1);
  4284.  
  4285.   return 1;
  4286. }
  4287. HTSEXT_API int hts_uninit(void) {
  4288.   hts_freevar();
  4289.   /* htswrap_free(); */
  4290.   return 1;
  4291. }
  4292.  
  4293. // defaut wrappers
  4294. void __cdecl htsdefault_init(void) {
  4295. }
  4296. void __cdecl htsdefault_uninit(void) {
  4297.   hts_freevar();
  4298. }
  4299. int __cdecl htsdefault_start(void* opt) {
  4300.   return 1; 
  4301. }
  4302. int __cdecl htsdefault_chopt(void* opt) {
  4303.   return 1;
  4304. }
  4305. int  __cdecl htsdefault_end(void) { 
  4306.   return 1; 
  4307. }
  4308. int __cdecl htsdefault_checkhtml(char* html,int len,char* url_adresse,char* url_fichier) {
  4309.   return 1;
  4310. }
  4311. int __cdecl htsdefault_loop(void* back,int back_max,int back_index,int lien_n,int lien_tot,int stat_time,hts_stat_struct* stats) {    // appelÈ ‡ chaque boucle de HTTrack
  4312.   return 1;
  4313. }
  4314. char* __cdecl htsdefault_query(char* question) {
  4315.   return "";
  4316. }
  4317. char* __cdecl htsdefault_query2(char* question) {
  4318.   return "";
  4319. }
  4320. char* __cdecl htsdefault_query3(char* question) {
  4321.   return "";
  4322. }
  4323. int __cdecl htsdefault_check(char* adr,char* fil,int status) {
  4324.   return -1;
  4325. }
  4326. void __cdecl htsdefault_pause(char* lockfile) {
  4327.   while (fexist(lockfile)) {
  4328.     Sleep(1000);
  4329.   }
  4330. }
  4331. void __cdecl htsdefault_filesave(char* file) {
  4332. }
  4333. int __cdecl htsdefault_linkdetected(char* link) {
  4334.   return 1;
  4335. }
  4336. int __cdecl htsdefault_xfrstatus(void* back) {
  4337.   return 1;
  4338. }
  4339. int __cdecl htsdefault_savename(char* adr_complete,char* fil_complete,char* referer_adr,char* referer_fil,char* save) {
  4340.   return 1;
  4341. }
  4342. // end defaut wrappers
  4343.  
  4344.  
  4345.  
  4346. // Fin
  4347.  
  4348.